/* individual-aggregator.c generated by valac 0.17.6.5-65f99, the Vala compiler
 * generated from individual-aggregator.vala, do not modify */

/*
 * Copyright (C) 2010 Collabora Ltd.
 * Copyright (C) 2012 Philip Withnall
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors:
 *       Travis Reitter <travis.reitter@collabora.co.uk>
 *       Philip Withnall <philip@tecnocode.co.uk>
 */

#include <glib.h>
#include <glib-object.h>
#include <gee.h>
#include <stdlib.h>
#include <string.h>
#include <gio/gio.h>
#include <folks-internal.h>
#include <glib/gi18n-lib.h>
#include <config.h>


#define FOLKS_TYPE_INDIVIDUAL_AGGREGATOR (folks_individual_aggregator_get_type ())
#define FOLKS_INDIVIDUAL_AGGREGATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregator))
#define FOLKS_INDIVIDUAL_AGGREGATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregatorClass))
#define FOLKS_IS_INDIVIDUAL_AGGREGATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_INDIVIDUAL_AGGREGATOR))
#define FOLKS_IS_INDIVIDUAL_AGGREGATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_INDIVIDUAL_AGGREGATOR))
#define FOLKS_INDIVIDUAL_AGGREGATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregatorClass))

typedef struct _FolksIndividualAggregator FolksIndividualAggregator;
typedef struct _FolksIndividualAggregatorClass FolksIndividualAggregatorClass;
typedef struct _FolksIndividualAggregatorPrivate FolksIndividualAggregatorPrivate;

#define FOLKS_TYPE_BACKEND_STORE (folks_backend_store_get_type ())
#define FOLKS_BACKEND_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_BACKEND_STORE, FolksBackendStore))
#define FOLKS_BACKEND_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_BACKEND_STORE, FolksBackendStoreClass))
#define FOLKS_IS_BACKEND_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_BACKEND_STORE))
#define FOLKS_IS_BACKEND_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_BACKEND_STORE))
#define FOLKS_BACKEND_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_BACKEND_STORE, FolksBackendStoreClass))

typedef struct _FolksBackendStore FolksBackendStore;
typedef struct _FolksBackendStoreClass FolksBackendStoreClass;

#define FOLKS_TYPE_PERSONA_STORE (folks_persona_store_get_type ())
#define FOLKS_PERSONA_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore))
#define FOLKS_PERSONA_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_PERSONA_STORE, FolksPersonaStoreClass))
#define FOLKS_IS_PERSONA_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_PERSONA_STORE))
#define FOLKS_IS_PERSONA_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_PERSONA_STORE))
#define FOLKS_PERSONA_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_PERSONA_STORE, FolksPersonaStoreClass))

typedef struct _FolksPersonaStore FolksPersonaStore;
typedef struct _FolksPersonaStoreClass FolksPersonaStoreClass;

#define FOLKS_TYPE_BACKEND (folks_backend_get_type ())
#define FOLKS_BACKEND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_BACKEND, FolksBackend))
#define FOLKS_BACKEND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_BACKEND, FolksBackendClass))
#define FOLKS_IS_BACKEND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_BACKEND))
#define FOLKS_IS_BACKEND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_BACKEND))
#define FOLKS_BACKEND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_BACKEND, FolksBackendClass))

typedef struct _FolksBackend FolksBackend;
typedef struct _FolksBackendClass FolksBackendClass;

#define FOLKS_TYPE_INDIVIDUAL (folks_individual_get_type ())
#define FOLKS_INDIVIDUAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_INDIVIDUAL, FolksIndividual))
#define FOLKS_INDIVIDUAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_INDIVIDUAL, FolksIndividualClass))
#define FOLKS_IS_INDIVIDUAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_INDIVIDUAL))
#define FOLKS_IS_INDIVIDUAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_INDIVIDUAL))
#define FOLKS_INDIVIDUAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_INDIVIDUAL, FolksIndividualClass))

typedef struct _FolksIndividual FolksIndividual;
typedef struct _FolksIndividualClass FolksIndividualClass;

#define FOLKS_TYPE_DEBUG (folks_debug_get_type ())
#define FOLKS_DEBUG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_DEBUG, FolksDebug))
#define FOLKS_DEBUG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_DEBUG, FolksDebugClass))
#define FOLKS_IS_DEBUG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_DEBUG))
#define FOLKS_IS_DEBUG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_DEBUG))
#define FOLKS_DEBUG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_DEBUG, FolksDebugClass))

typedef struct _FolksDebug FolksDebug;
typedef struct _FolksDebugClass FolksDebugClass;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))

#define FOLKS_TYPE_TRUST_LEVEL (folks_trust_level_get_type ())

#define FOLKS_TYPE_PERSONA (folks_persona_get_type ())
#define FOLKS_PERSONA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_PERSONA, FolksPersona))
#define FOLKS_PERSONA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_PERSONA, FolksPersonaClass))
#define FOLKS_IS_PERSONA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_PERSONA))
#define FOLKS_IS_PERSONA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_PERSONA))
#define FOLKS_PERSONA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_PERSONA, FolksPersonaClass))

typedef struct _FolksPersona FolksPersona;
typedef struct _FolksPersonaClass FolksPersonaClass;
typedef struct _FolksIndividualAggregatorPrepareData FolksIndividualAggregatorPrepareData;
typedef struct _FolksIndividualAggregatorUnprepareData FolksIndividualAggregatorUnprepareData;

#define FOLKS_TYPE_MATCH_RESULT (folks_match_result_get_type ())

#define FOLKS_TYPE_POTENTIAL_MATCH (folks_potential_match_get_type ())
#define FOLKS_POTENTIAL_MATCH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_POTENTIAL_MATCH, FolksPotentialMatch))
#define FOLKS_POTENTIAL_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_POTENTIAL_MATCH, FolksPotentialMatchClass))
#define FOLKS_IS_POTENTIAL_MATCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_POTENTIAL_MATCH))
#define FOLKS_IS_POTENTIAL_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_POTENTIAL_MATCH))
#define FOLKS_POTENTIAL_MATCH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_POTENTIAL_MATCH, FolksPotentialMatchClass))

typedef struct _FolksPotentialMatch FolksPotentialMatch;
typedef struct _FolksPotentialMatchClass FolksPotentialMatchClass;
typedef struct _FolksIndividualAggregatorAddBackendData FolksIndividualAggregatorAddBackendData;
typedef struct _Block4Data Block4Data;

#define FOLKS_GROUP_DETAILS_TYPE_CHANGE_REASON (folks_group_details_change_reason_get_type ())
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
typedef struct _Block5Data Block5Data;

#define FOLKS_TYPE_PERSONA_STORE_TRUST (folks_persona_store_trust_get_type ())
typedef struct _Block6Data Block6Data;

#define FOLKS_TYPE_ANTI_LINKABLE (folks_anti_linkable_get_type ())
#define FOLKS_ANTI_LINKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_ANTI_LINKABLE, FolksAntiLinkable))
#define FOLKS_IS_ANTI_LINKABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_ANTI_LINKABLE))
#define FOLKS_ANTI_LINKABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), FOLKS_TYPE_ANTI_LINKABLE, FolksAntiLinkableIface))

typedef struct _FolksAntiLinkable FolksAntiLinkable;
typedef struct _FolksAntiLinkableIface FolksAntiLinkableIface;
typedef struct _Block7Data Block7Data;
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
typedef struct _FolksIndividualAggregatorAddPersonaFromDetailsData FolksIndividualAggregatorAddPersonaFromDetailsData;
typedef struct _Block8Data Block8Data;
typedef struct _FolksIndividualAggregatorRemoveIndividualData FolksIndividualAggregatorRemoveIndividualData;
typedef struct _FolksIndividualAggregatorRemovePersonaData FolksIndividualAggregatorRemovePersonaData;
typedef struct _FolksIndividualAggregatorLinkPersonasData FolksIndividualAggregatorLinkPersonasData;

#define FOLKS_TYPE_ABSTRACT_FIELD_DETAILS (folks_abstract_field_details_get_type ())
#define FOLKS_ABSTRACT_FIELD_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_ABSTRACT_FIELD_DETAILS, FolksAbstractFieldDetails))
#define FOLKS_ABSTRACT_FIELD_DETAILS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_ABSTRACT_FIELD_DETAILS, FolksAbstractFieldDetailsClass))
#define FOLKS_IS_ABSTRACT_FIELD_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_ABSTRACT_FIELD_DETAILS))
#define FOLKS_IS_ABSTRACT_FIELD_DETAILS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_ABSTRACT_FIELD_DETAILS))
#define FOLKS_ABSTRACT_FIELD_DETAILS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_ABSTRACT_FIELD_DETAILS, FolksAbstractFieldDetailsClass))

typedef struct _FolksAbstractFieldDetails FolksAbstractFieldDetails;
typedef struct _FolksAbstractFieldDetailsClass FolksAbstractFieldDetailsClass;

#define FOLKS_TYPE_IM_FIELD_DETAILS (folks_im_field_details_get_type ())
#define FOLKS_IM_FIELD_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_IM_FIELD_DETAILS, FolksImFieldDetails))
#define FOLKS_IM_FIELD_DETAILS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_IM_FIELD_DETAILS, FolksImFieldDetailsClass))
#define FOLKS_IS_IM_FIELD_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_IM_FIELD_DETAILS))
#define FOLKS_IS_IM_FIELD_DETAILS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_IM_FIELD_DETAILS))
#define FOLKS_IM_FIELD_DETAILS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_IM_FIELD_DETAILS, FolksImFieldDetailsClass))

typedef struct _FolksImFieldDetails FolksImFieldDetails;
typedef struct _FolksImFieldDetailsClass FolksImFieldDetailsClass;

#define FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS (folks_web_service_field_details_get_type ())
#define FOLKS_WEB_SERVICE_FIELD_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS, FolksWebServiceFieldDetails))
#define FOLKS_WEB_SERVICE_FIELD_DETAILS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS, FolksWebServiceFieldDetailsClass))
#define FOLKS_IS_WEB_SERVICE_FIELD_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS))
#define FOLKS_IS_WEB_SERVICE_FIELD_DETAILS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS))
#define FOLKS_WEB_SERVICE_FIELD_DETAILS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS, FolksWebServiceFieldDetailsClass))

typedef struct _FolksWebServiceFieldDetails FolksWebServiceFieldDetails;
typedef struct _FolksWebServiceFieldDetailsClass FolksWebServiceFieldDetailsClass;

#define FOLKS_TYPE_IM_DETAILS (folks_im_details_get_type ())
#define FOLKS_IM_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_IM_DETAILS, FolksImDetails))
#define FOLKS_IS_IM_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_IM_DETAILS))
#define FOLKS_IM_DETAILS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), FOLKS_TYPE_IM_DETAILS, FolksImDetailsIface))

typedef struct _FolksImDetails FolksImDetails;
typedef struct _FolksImDetailsIface FolksImDetailsIface;

#define FOLKS_TYPE_WEB_SERVICE_DETAILS (folks_web_service_details_get_type ())
#define FOLKS_WEB_SERVICE_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_WEB_SERVICE_DETAILS, FolksWebServiceDetails))
#define FOLKS_IS_WEB_SERVICE_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_WEB_SERVICE_DETAILS))
#define FOLKS_WEB_SERVICE_DETAILS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), FOLKS_TYPE_WEB_SERVICE_DETAILS, FolksWebServiceDetailsIface))

typedef struct _FolksWebServiceDetails FolksWebServiceDetails;
typedef struct _FolksWebServiceDetailsIface FolksWebServiceDetailsIface;

#define FOLKS_TYPE_LOCAL_ID_DETAILS (folks_local_id_details_get_type ())
#define FOLKS_LOCAL_ID_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_LOCAL_ID_DETAILS, FolksLocalIdDetails))
#define FOLKS_IS_LOCAL_ID_DETAILS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_LOCAL_ID_DETAILS))
#define FOLKS_LOCAL_ID_DETAILS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), FOLKS_TYPE_LOCAL_ID_DETAILS, FolksLocalIdDetailsIface))

typedef struct _FolksLocalIdDetails FolksLocalIdDetails;
typedef struct _FolksLocalIdDetailsIface FolksLocalIdDetailsIface;

#define FOLKS_TYPE_PERSONA_DETAIL (folks_persona_detail_get_type ())
typedef struct _FolksIndividualAggregatorUnlinkIndividualData FolksIndividualAggregatorUnlinkIndividualData;
typedef struct _FolksIndividualAggregatorEnsureIndividualPropertyWriteableData FolksIndividualAggregatorEnsureIndividualPropertyWriteableData;
typedef struct _FolksIndividualAggregatorEnsurePersonasPropertyWriteableData FolksIndividualAggregatorEnsurePersonasPropertyWriteableData;
typedef struct _FolksIndividualAggregatorLookUpIndividualData FolksIndividualAggregatorLookUpIndividualData;
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

/**
 * Errors from {@link IndividualAggregator}s.
 */
typedef enum  {
	FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_ADD_FAILED,
	FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_NO_WRITEABLE_STORE,
	FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_STORE_OFFLINE,
	FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_PROPERTY_NOT_WRITEABLE,
	FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_NO_PRIMARY_STORE
} FolksIndividualAggregatorError;
#define FOLKS_INDIVIDUAL_AGGREGATOR_ERROR folks_individual_aggregator_error_quark ()
struct _FolksIndividualAggregator {
	GObject parent_instance;
	FolksIndividualAggregatorPrivate * priv;
};

struct _FolksIndividualAggregatorClass {
	GObjectClass parent_class;
};

struct _FolksIndividualAggregatorPrivate {
	FolksBackendStore* _backend_store;
	GeeHashMap* _stores;
	FolksPersonaStore* _primary_store;
	GeeHashSet* _backends;
	GeeHashMultiMap* _link_map;
	gboolean _linking_enabled;
	gboolean _is_prepared;
	GStaticRecMutex __lock__is_prepared;
	gboolean _prepare_pending;
	FolksDebug* _debug;
	gchar* _configured_primary_store_type_id;
	gchar* _configured_primary_store_id;
	guint _non_quiescent_persona_store_count;
	guint _non_quiescent_backend_count;
	gboolean _is_quiescent;
	guint _quiescent_timeout_id;
	gboolean _user_configured_primary_store;
	GeeMap* _individuals;
	GeeMap* _individuals_ro;
	FolksIndividual* _user;
};

typedef enum  {
	FOLKS_TRUST_LEVEL_NONE,
	FOLKS_TRUST_LEVEL_PERSONAS
} FolksTrustLevel;

struct _FolksIndividualAggregatorPrepareData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	gboolean _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	gboolean _tmp3_;
	guint _tmp4_;
	FolksBackendStore* _tmp5_;
	FolksBackendStore* _tmp6_;
	GeeMap* _tmp7_;
	GeeMap* _tmp8_;
	GeeCollection* _tmp9_;
	GeeCollection* _tmp10_;
	GeeCollection* backends;
	GeeCollection* _tmp11_;
	GeeIterator* _tmp12_;
	GeeIterator* _backend_it;
	GeeIterator* _tmp13_;
	gboolean _tmp14_;
	GeeIterator* _tmp15_;
	gpointer _tmp16_;
	FolksBackend* backend;
	FolksBackendStore* _tmp17_;
	FolksBackend* _tmp18_;
	FolksBackendStore* _tmp19_;
	guint _tmp20_;
	gboolean _tmp21_;
	GError * _inner_error_;
};

struct _FolksIndividualAggregatorUnprepareData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	gboolean _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	GeeHashMap* _tmp6_;
	GeeCollection* _tmp7_;
	GeeCollection* _tmp8_;
	GeeCollection* _tmp9_;
	GeeIterator* _tmp10_;
	GeeIterator* _tmp11_;
	GeeIterator* _p_it;
	GeeIterator* _tmp12_;
	gboolean _tmp13_;
	GeeIterator* _tmp14_;
	gpointer _tmp15_;
	FolksPersonaStore* p;
	FolksPersonaStore* _tmp16_;
	gboolean _tmp17_;
	gboolean _tmp18_;
	GError * _inner_error_;
};

typedef enum  {
	FOLKS_MATCH_RESULT_NONE = -1,
	FOLKS_MATCH_RESULT_VERY_LOW = 0,
	FOLKS_MATCH_RESULT_LOW = 1,
	FOLKS_MATCH_RESULT_MEDIUM = 2,
	FOLKS_MATCH_RESULT_HIGH = 3,
	FOLKS_MATCH_RESULT_VERY_HIGH = 4,
	FOLKS_MATCH_RESULT_MIN = FOLKS_MATCH_RESULT_NONE,
	FOLKS_MATCH_RESULT_MAX = FOLKS_MATCH_RESULT_VERY_HIGH
} FolksMatchResult;

struct _FolksIndividualAggregatorAddBackendData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	FolksBackend* backend;
	GeeHashSet* _tmp0_;
	FolksBackend* _tmp1_;
	gboolean _tmp2_;
	GeeHashSet* _tmp3_;
	FolksBackend* _tmp4_;
	FolksBackend* _tmp5_;
	FolksBackend* _tmp6_;
	FolksBackend* _tmp7_;
	FolksBackend* _tmp8_;
	GeeMap* _tmp9_;
	GeeMap* _tmp10_;
	GeeCollection* _tmp11_;
	GeeCollection* _tmp12_;
	GeeCollection* _tmp13_;
	gint _tmp14_;
	gpointer* _tmp15_;
	FolksPersonaStore** _tmp16_;
	gint _tmp16__length1;
	FolksPersonaStore** stores;
	gint stores_length1;
	gint _stores_size_;
	FolksPersonaStore** _tmp17_;
	gint _tmp17__length1;
	FolksPersonaStore** persona_store_collection;
	gint persona_store_collection_length1;
	gint _persona_store_collection_size_;
	gint persona_store_it;
	FolksPersonaStore* _tmp18_;
	FolksPersonaStore* persona_store;
	FolksBackend* _tmp19_;
	FolksPersonaStore* _tmp20_;
};

struct _Block4Data {
	int _ref_count_;
	FolksIndividualAggregator * self;
	gchar* store_id;
	FolksPersonaStore* store;
};

typedef enum  {
	FOLKS_GROUP_DETAILS_CHANGE_REASON_NONE = 0,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_OFFLINE = 1,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_KICKED = 2,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_BUSY = 3,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_INVITED = 4,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_BANNED = 5,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_ERROR = 6,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_INVALID_MEMBER = 7,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_NO_ANSWER = 8,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_RENAMED = 9,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_PERMISSION_DENIED = 10,
	FOLKS_GROUP_DETAILS_CHANGE_REASON_SEPARATED = 11
} FolksGroupDetailsChangeReason;

struct _Block5Data {
	int _ref_count_;
	FolksIndividualAggregator * self;
	FolksPersona* persona;
	GeeHashSet* candidate_inds;
};

typedef enum  {
	FOLKS_PERSONA_STORE_TRUST_NONE,
	FOLKS_PERSONA_STORE_TRUST_PARTIAL,
	FOLKS_PERSONA_STORE_TRUST_FULL
} FolksPersonaStoreTrust;

struct _Block6Data {
	int _ref_count_;
	Block5Data * _data5_;
	const gchar* prop_name;
};

typedef void (*FolksPersonaLinkablePropertyCallback) (const gchar* link, void* user_data);
typedef enum  {
	FOLKS_PROPERTY_ERROR_NOT_WRITEABLE,
	FOLKS_PROPERTY_ERROR_INVALID_VALUE,
	FOLKS_PROPERTY_ERROR_UNKNOWN_ERROR,
	FOLKS_PROPERTY_ERROR_UNAVAILABLE
} FolksPropertyError;
#define FOLKS_PROPERTY_ERROR folks_property_error_quark ()
struct _FolksAntiLinkableIface {
	GTypeInterface parent_iface;
	void (*change_anti_links) (FolksAntiLinkable* self, GeeSet* anti_links, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*change_anti_links_finish) (FolksAntiLinkable* self, GAsyncResult* _res_, GError** error);
	GeeSet* (*get_anti_links) (FolksAntiLinkable* self);
	void (*set_anti_links) (FolksAntiLinkable* self, GeeSet* value);
};

struct _Block7Data {
	int _ref_count_;
	FolksIndividualAggregator * self;
	FolksIndividual* individual;
};

typedef enum  {
	FOLKS_PERSONA_STORE_ERROR_INVALID_ARGUMENT,
	FOLKS_PERSONA_STORE_ERROR_CREATE_FAILED,
	FOLKS_PERSONA_STORE_ERROR_UNSUPPORTED_ON_USER,
	FOLKS_PERSONA_STORE_ERROR_STORE_OFFLINE,
	FOLKS_PERSONA_STORE_ERROR_READ_ONLY,
	FOLKS_PERSONA_STORE_ERROR_PERMISSION_DENIED,
	FOLKS_PERSONA_STORE_ERROR_REMOVE_FAILED,
	FOLKS_PERSONA_STORE_ERROR_UNSUPPORTED_ON_NON_USER
} FolksPersonaStoreError;
#define FOLKS_PERSONA_STORE_ERROR folks_persona_store_error_quark ()
struct _FolksIndividualAggregatorAddPersonaFromDetailsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	FolksIndividual* parent;
	FolksPersonaStore* persona_store;
	GHashTable* details;
	FolksPersona* result;
	FolksPersona* persona;
	GHashTable* _tmp0_;
	GHashTable* _tmp1_;
	GHashTable* details_copy;
	FolksPersonaStore* _tmp2_;
	GHashTable* _tmp3_;
	FolksPersona* _tmp4_;
	FolksPersona* _tmp5_;
	GError* e;
	GError* _tmp6_;
	GError* _tmp7_;
	const gchar* _tmp8_;
	GError* _tmp9_;
	FolksPersonaStore* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	FolksPersonaStore* _tmp13_;
	const gchar* _tmp14_;
	const gchar* _tmp15_;
	gchar* _tmp16_;
	gchar* full_id;
	const gchar* _tmp17_;
	const gchar* _tmp18_;
	GError* _tmp19_;
	const gchar* _tmp20_;
	GError* _tmp21_;
	gboolean _tmp22_;
	FolksIndividual* _tmp23_;
	FolksPersona* _tmp24_;
	gboolean _tmp25_;
	FolksIndividual* _tmp26_;
	GeeSet* _tmp27_;
	GeeSet* _tmp28_;
	FolksPersona* _tmp29_;
	GError * _inner_error_;
};

struct _Block8Data {
	int _ref_count_;
	FolksIndividualAggregator * self;
	GHashTable* retval;
};

struct _FolksIndividualAggregatorRemoveIndividualData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	FolksIndividual* individual;
	GeeHashSet* _tmp0_;
	GeeHashSet* personas;
	FolksIndividual* _tmp1_;
	GeeSet* _tmp2_;
	GeeSet* _tmp3_;
	GeeIterator* _tmp4_;
	GeeIterator* _p_it;
	GeeIterator* _tmp5_;
	gboolean _tmp6_;
	GeeIterator* _tmp7_;
	gpointer _tmp8_;
	FolksPersona* p;
	GeeHashSet* _tmp9_;
	FolksPersona* _tmp10_;
	GeeHashSet* _tmp11_;
	GeeIterator* _tmp12_;
	GeeIterator* _persona_it;
	GeeIterator* _tmp13_;
	gboolean _tmp14_;
	GeeIterator* _tmp15_;
	gpointer _tmp16_;
	FolksPersona* persona;
	FolksPersona* _tmp17_;
	FolksPersonaStore* _tmp18_;
	FolksPersonaStore* _tmp19_;
	FolksPersona* _tmp20_;
	GError * _inner_error_;
};

struct _FolksIndividualAggregatorRemovePersonaData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	FolksPersona* persona;
	FolksPersona* _tmp0_;
	FolksPersonaStore* _tmp1_;
	FolksPersonaStore* _tmp2_;
	FolksPersona* _tmp3_;
	GError * _inner_error_;
};

struct _FolksIndividualAggregatorLinkPersonasData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	GeeSet* personas;
	FolksPersonaStore* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	const gchar* _tmp12_;
	const gchar* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	GError* _tmp16_;
	GError* _tmp17_;
	GeeSet* _tmp18_;
	gint _tmp19_;
	gint _tmp20_;
	gboolean _tmp21_;
	GeeSet* _tmp22_;
	GeeIterator* _tmp23_;
	GeeIterator* _p_it;
	GeeIterator* _tmp24_;
	gboolean _tmp25_;
	GeeIterator* _tmp26_;
	gpointer _tmp27_;
	FolksPersona* p;
	FolksPersona* _tmp28_;
	FolksAntiLinkable* _tmp29_;
	FolksAntiLinkable* al;
	FolksAntiLinkable* _tmp30_;
	FolksAntiLinkable* _tmp31_;
	GeeSet* _tmp32_;
	GError* e;
	const gchar* _tmp33_;
	GError* _tmp34_;
	FolksPersonaStore* _tmp35_;
	const gchar* _tmp36_;
	const gchar* _tmp37_;
	const gchar* _tmp38_;
	GeeSet* _tmp39_;
	GHashTable* _tmp40_;
	GHashTable* details;
	FolksPersonaStore* _tmp41_;
	GHashTable* _tmp42_;
	FolksPersona* _tmp43_;
	FolksPersona* _tmp44_;
	GError * _inner_error_;
};

struct _FolksImDetailsIface {
	GTypeInterface parent_iface;
	void (*change_im_addresses) (FolksImDetails* self, GeeMultiMap* im_addresses, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*change_im_addresses_finish) (FolksImDetails* self, GAsyncResult* _res_, GError** error);
	GeeMultiMap* (*get_im_addresses) (FolksImDetails* self);
	void (*set_im_addresses) (FolksImDetails* self, GeeMultiMap* value);
};

struct _FolksWebServiceDetailsIface {
	GTypeInterface parent_iface;
	void (*change_web_service_addresses) (FolksWebServiceDetails* self, GeeMultiMap* web_service_addresses, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*change_web_service_addresses_finish) (FolksWebServiceDetails* self, GAsyncResult* _res_, GError** error);
	GeeMultiMap* (*get_web_service_addresses) (FolksWebServiceDetails* self);
	void (*set_web_service_addresses) (FolksWebServiceDetails* self, GeeMultiMap* value);
};

struct _FolksLocalIdDetailsIface {
	GTypeInterface parent_iface;
	void (*change_local_ids) (FolksLocalIdDetails* self, GeeSet* local_ids, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*change_local_ids_finish) (FolksLocalIdDetails* self, GAsyncResult* _res_, GError** error);
	GeeSet* (*get_local_ids) (FolksLocalIdDetails* self);
	void (*set_local_ids) (FolksLocalIdDetails* self, GeeSet* value);
};

typedef enum  {
	FOLKS_PERSONA_DETAIL_INVALID = -1,
	FOLKS_PERSONA_DETAIL_ALIAS = 0,
	FOLKS_PERSONA_DETAIL_AVATAR,
	FOLKS_PERSONA_DETAIL_BIRTHDAY,
	FOLKS_PERSONA_DETAIL_EMAIL_ADDRESSES,
	FOLKS_PERSONA_DETAIL_FULL_NAME,
	FOLKS_PERSONA_DETAIL_GENDER,
	FOLKS_PERSONA_DETAIL_IM_ADDRESSES,
	FOLKS_PERSONA_DETAIL_IS_FAVOURITE,
	FOLKS_PERSONA_DETAIL_LOCAL_IDS,
	FOLKS_PERSONA_DETAIL_NICKNAME,
	FOLKS_PERSONA_DETAIL_NOTES,
	FOLKS_PERSONA_DETAIL_PHONE_NUMBERS,
	FOLKS_PERSONA_DETAIL_POSTAL_ADDRESSES,
	FOLKS_PERSONA_DETAIL_ROLES,
	FOLKS_PERSONA_DETAIL_STRUCTURED_NAME,
	FOLKS_PERSONA_DETAIL_URLS,
	FOLKS_PERSONA_DETAIL_WEB_SERVICE_ADDRESSES,
	FOLKS_PERSONA_DETAIL_GROUPS,
	FOLKS_PERSONA_DETAIL_IM_INTERACTION_COUNT,
	FOLKS_PERSONA_DETAIL_LAST_IM_INTERACTION_DATETIME,
	FOLKS_PERSONA_DETAIL_CALL_INTERACTION_COUNT,
	FOLKS_PERSONA_DETAIL_LAST_CALL_INTERACTION_DATETIME,
	FOLKS_PERSONA_DETAIL_ANTI_LINKS
} FolksPersonaDetail;

struct _FolksIndividualAggregatorUnlinkIndividualData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	FolksIndividual* individual;
	gboolean _tmp0_;
	FolksIndividual* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	FolksIndividual* _tmp4_;
	const gchar* _tmp5_;
	const gchar* _tmp6_;
	GeeHashSet* _tmp7_;
	GeeHashSet* individual_personas;
	GeeHashSet* _tmp8_;
	FolksIndividual* _tmp9_;
	GeeSet* _tmp10_;
	GeeSet* _tmp11_;
	GeeHashSet* _tmp12_;
	GeeIterator* _tmp13_;
	GeeIterator* _pers_it;
	GeeIterator* _tmp14_;
	gboolean _tmp15_;
	GeeIterator* _tmp16_;
	gpointer _tmp17_;
	FolksPersona* pers;
	GeeHashSet* _tmp18_;
	GeeHashSet* personas;
	GeeHashSet* _tmp19_;
	FolksPersona* _tmp20_;
	FolksPersona* _tmp21_;
	const gchar* _tmp22_;
	const gchar* _tmp23_;
	FolksPersona* _tmp24_;
	GeeHashSet* _tmp25_;
	FolksPersona* _tmp26_;
	FolksPersona* writeable_persona;
	FolksPersona* _tmp27_;
	const gchar* _tmp28_;
	const gchar* _tmp29_;
	FolksPersona* _tmp30_;
	GeeHashSet* _tmp31_;
	GeeHashSet* anti_link_personas;
	GeeHashSet* _tmp32_;
	GeeHashSet* _tmp33_;
	GeeHashSet* _tmp34_;
	FolksPersona* _tmp35_;
	FolksPersona* _tmp36_;
	FolksAntiLinkable* _tmp37_;
	FolksAntiLinkable* al;
	FolksAntiLinkable* _tmp38_;
	FolksAntiLinkable* _tmp39_;
	GeeHashSet* _tmp40_;
	GError* e1;
	GError* _tmp41_;
	const gchar* _tmp42_;
	GError * _inner_error_;
};

struct _FolksIndividualAggregatorEnsureIndividualPropertyWriteableData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	FolksIndividual* individual;
	gchar* property_name;
	FolksPersona* result;
	FolksIndividual* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	FolksIndividual* _tmp4_;
	GeeSet* _tmp5_;
	GeeSet* _tmp6_;
	const gchar* _tmp7_;
	FolksPersona* _tmp8_;
	FolksPersona* p;
	GError * _inner_error_;
};

struct _FolksIndividualAggregatorEnsurePersonasPropertyWriteableData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	GeeSet* personas;
	gchar* property_name;
	FolksPersona* result;
	GeeSet* _tmp0_;
	GeeIterator* _tmp1_;
	GeeIterator* _p1_it;
	GeeIterator* _tmp2_;
	gboolean _tmp3_;
	GeeIterator* _tmp4_;
	gpointer _tmp5_;
	FolksPersona* p1;
	const gchar* _tmp6_;
	FolksPersona* _tmp7_;
	gchar** _tmp8_;
	gint _tmp8__length1;
	gchar** _tmp9_;
	gint _tmp9__length1;
	FolksPersona* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	GeeSet* _tmp13_;
	GHashTable* _tmp14_;
	GHashTable* details;
	FolksPersona* new_persona;
	gboolean _tmp15_;
	FolksPersonaStore* _tmp16_;
	const gchar* _tmp17_;
	FolksPersonaStore* _tmp18_;
	gchar** _tmp19_;
	gint _tmp19__length1;
	gchar** _tmp20_;
	gint _tmp20__length1;
	gboolean _tmp21_;
	FolksPersonaStore* _tmp22_;
	GHashTable* _tmp23_;
	FolksPersona* _tmp24_;
	FolksPersona* _tmp25_;
	GError* e1;
	FolksPersona* _tmp26_;
	GeeHashMap* _tmp27_;
	GeeCollection* _tmp28_;
	GeeCollection* _tmp29_;
	GeeCollection* _tmp30_;
	GeeIterator* _tmp31_;
	GeeIterator* _tmp32_;
	GeeIterator* _s_it;
	GeeIterator* _tmp33_;
	gboolean _tmp34_;
	GeeIterator* _tmp35_;
	gpointer _tmp36_;
	FolksPersonaStore* s;
	gboolean _tmp37_;
	FolksPersonaStore* _tmp38_;
	FolksPersonaStore* _tmp39_;
	const gchar* _tmp40_;
	FolksPersonaStore* _tmp41_;
	gchar** _tmp42_;
	gint _tmp42__length1;
	gchar** _tmp43_;
	gint _tmp43__length1;
	gboolean _tmp44_;
	FolksPersonaStore* _tmp45_;
	const gchar* _tmp46_;
	const gchar* _tmp47_;
	FolksPersonaStore* _tmp48_;
	GHashTable* _tmp49_;
	FolksPersona* _tmp50_;
	FolksPersona* _tmp51_;
	GError* e2;
	gboolean _tmp52_;
	FolksPersona* _tmp53_;
	FolksPersonaStore* _tmp54_;
	gboolean _tmp55_;
	const gchar* _tmp56_;
	gchar* _tmp57_;
	gchar* _tmp58_;
	const gchar* _tmp59_;
	gchar* _tmp60_;
	gchar* _tmp61_;
	gchar* _tmp62_;
	gchar* _tmp63_;
	const gchar* _tmp64_;
	gchar* _tmp65_;
	gchar* _tmp66_;
	const gchar* _tmp67_;
	const gchar* _tmp68_;
	gchar* _tmp69_;
	gchar* _tmp70_;
	GError* _tmp71_;
	GError* _tmp72_;
	FolksPersona* _tmp73_;
	const gchar* _tmp74_;
	const gchar* _tmp75_;
	GError* _tmp76_;
	FolksPersona* _tmp77_;
	FolksPersona* _tmp78_;
	GError * _inner_error_;
};

struct _FolksIndividualAggregatorLookUpIndividualData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	FolksIndividualAggregator* self;
	gchar* id;
	FolksIndividual* result;
	GeeMap* _tmp0_;
	const gchar* _tmp1_;
	gpointer _tmp2_;
	GError * _inner_error_;
};


static gpointer folks_individual_aggregator_parent_class = NULL;

GQuark folks_individual_aggregator_error_quark (void);
GType folks_individual_aggregator_get_type (void) G_GNUC_CONST;
GType folks_backend_store_get_type (void) G_GNUC_CONST;
GType folks_persona_store_get_type (void) G_GNUC_CONST;
GType folks_backend_get_type (void) G_GNUC_CONST;
GType folks_individual_get_type (void) G_GNUC_CONST;
GType folks_debug_get_type (void) G_GNUC_CONST;
#define FOLKS_INDIVIDUAL_AGGREGATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregatorPrivate))
enum  {
	FOLKS_INDIVIDUAL_AGGREGATOR_DUMMY_PROPERTY,
	FOLKS_INDIVIDUAL_AGGREGATOR_IS_PREPARED,
	FOLKS_INDIVIDUAL_AGGREGATOR_IS_QUIESCENT,
	FOLKS_INDIVIDUAL_AGGREGATOR_PRIMARY_STORE,
	FOLKS_INDIVIDUAL_AGGREGATOR_INDIVIDUALS,
	FOLKS_INDIVIDUAL_AGGREGATOR_USER
};
static void _folks_individual_aggregator_backend_available_cb (FolksIndividualAggregator* self, FolksBackendStore* backend_store, FolksBackend* backend);
static void __folks_individual_aggregator_backend_available_cb_folks_backend_store_backend_available (FolksBackendStore* _sender, FolksBackend* backend, gpointer self);
static void _folks_individual_aggregator_debug_print_status (FolksIndividualAggregator* self, FolksDebug* debug);
static void __folks_individual_aggregator_debug_print_status_folks_debug_print_status (FolksDebug* _sender, gpointer self);
#define FOLKS_INDIVIDUAL_AGGREGATOR__FOLKS_GSETTINGS_SCHEMA "org.freedesktop.folks"
#define FOLKS_INDIVIDUAL_AGGREGATOR__PRIMARY_STORE_CONFIG_KEY "primary-store"
#define FOLKS_INDIVIDUAL_AGGREGATOR__QUIESCENT_TIMEOUT ((guint) 30)
FolksIndividualAggregator* folks_individual_aggregator_new (void);
FolksIndividualAggregator* folks_individual_aggregator_construct (GType object_type);
static void _folks_individual_aggregator_configure_primary_store (FolksIndividualAggregator* self, const gchar* store_config_ids);
#define FOLKS_DEBUG_STATUS_LOG_DOMAIN "folks-status"
void folks_debug_print_heading (FolksDebug* self, const gchar* domain, GLogLevelFlags level, const gchar* format, ...);
void folks_debug_print_key_value_pairs (FolksDebug* self, const gchar* domain, GLogLevelFlags level, ...);
void folks_debug_print_line (FolksDebug* self, const gchar* domain, GLogLevelFlags level, const gchar* format, ...);
GeeMap* folks_individual_aggregator_get_individuals (FolksIndividualAggregator* self);
void folks_debug_indent (FolksDebug* self);
GType folks_trust_level_get_type (void) G_GNUC_CONST;
FolksTrustLevel folks_individual_get_trust_level (FolksIndividual* self);
gboolean folks_individual_get_is_user (FolksIndividual* self);
const gchar* folks_individual_get_id (FolksIndividual* self);
GType folks_persona_get_type (void) G_GNUC_CONST;
GeeSet* folks_individual_get_personas (FolksIndividual* self);
gboolean folks_persona_get_is_user (FolksPersona* self);
const gchar* folks_persona_get_uid (FolksPersona* self);
const gchar* folks_persona_get_iid (FolksPersona* self);
const gchar* folks_persona_get_display_id (FolksPersona* self);
void folks_debug_unindent (FolksDebug* self);
static void folks_individual_aggregator_prepare_data_free (gpointer _data);
void folks_individual_aggregator_prepare (FolksIndividualAggregator* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_individual_aggregator_prepare_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_prepare_co (FolksIndividualAggregatorPrepareData* _data_);
GeeMap* folks_backend_store_get_enabled_backends (FolksBackendStore* self);
void folks_backend_store_load_backends (FolksBackendStore* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_backend_store_load_backends_finish (FolksBackendStore* self, GAsyncResult* _res_, GError** error);
static void folks_individual_aggregator_prepare_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _folks_individual_aggregator_notify_if_is_quiescent (FolksIndividualAggregator* self);
static void folks_individual_aggregator_unprepare_data_free (gpointer _data);
void folks_individual_aggregator_unprepare (FolksIndividualAggregator* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_individual_aggregator_unprepare_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_unprepare_co (FolksIndividualAggregatorUnprepareData* _data_);
void folks_persona_store_flush (FolksPersonaStore* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_persona_store_flush_finish (FolksPersonaStore* self, GAsyncResult* _res_);
static void folks_individual_aggregator_unprepare_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
GType folks_match_result_get_type (void) G_GNUC_CONST;
GeeMap* folks_individual_aggregator_get_potential_matches (FolksIndividualAggregator* self, FolksIndividual* matchee, FolksMatchResult min_threshold);
FolksPotentialMatch* folks_potential_match_new (void);
FolksPotentialMatch* folks_potential_match_construct (GType object_type);
GType folks_potential_match_get_type (void) G_GNUC_CONST;
FolksMatchResult folks_potential_match_potential_match (FolksPotentialMatch* self, FolksIndividual* a, FolksIndividual* b);
GeeMap* folks_individual_aggregator_get_all_potential_matches (FolksIndividualAggregator* self, FolksMatchResult min_threshold);
static void _folks_individual_aggregator_add_backend_data_free (gpointer _data);
static void _folks_individual_aggregator_add_backend (FolksIndividualAggregator* self, FolksBackend* backend, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void _folks_individual_aggregator_add_backend_finish (FolksIndividualAggregator* self, GAsyncResult* _res_);
static gboolean _folks_individual_aggregator_add_backend_co (FolksIndividualAggregatorAddBackendData* _data_);
static void _folks_individual_aggregator_backend_persona_store_added_cb (FolksIndividualAggregator* self, FolksBackend* backend, FolksPersonaStore* store);
static void __folks_individual_aggregator_backend_persona_store_added_cb_folks_backend_persona_store_added (FolksBackend* _sender, FolksPersonaStore* store, gpointer self);
static void _folks_individual_aggregator_backend_persona_store_removed_cb (FolksIndividualAggregator* self, FolksBackend* backend, FolksPersonaStore* store);
static void __folks_individual_aggregator_backend_persona_store_removed_cb_folks_backend_persona_store_removed (FolksBackend* _sender, FolksPersonaStore* store, gpointer self);
static void _folks_individual_aggregator_backend_is_quiescent_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec);
static void __folks_individual_aggregator_backend_is_quiescent_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
GeeMap* folks_backend_get_persona_stores (FolksBackend* self);
gboolean folks_backend_get_is_quiescent (FolksBackend* self);
static gboolean _folks_individual_aggregator_quiescent_timeout_cb (FolksIndividualAggregator* self);
static gboolean __folks_individual_aggregator_quiescent_timeout_cb_gsource_func (gpointer self);
static void _folks_individual_aggregator_set_primary_store (FolksIndividualAggregator* self, FolksPersonaStore* store);
const gchar* folks_persona_store_get_type_id (FolksPersonaStore* self);
const gchar* folks_persona_store_get_id (FolksPersonaStore* self);
void folks_persona_store_set_is_primary_store (FolksPersonaStore* self, gboolean value);
static Block4Data* block4_data_ref (Block4Data* _data4_);
static void block4_data_unref (void * _userdata_);
const gchar* folks_backend_get_name (FolksBackend* self);
static gchar* _folks_individual_aggregator_get_store_full_id (FolksIndividualAggregator* self, const gchar* type_id, const gchar* id);
static gboolean _folks_individual_aggregator_maybe_configure_as_primary (FolksIndividualAggregator* self, FolksPersonaStore* store);
GType folks_group_details_change_reason_get_type (void) G_GNUC_CONST;
static void _folks_individual_aggregator_personas_changed_cb (FolksIndividualAggregator* self, FolksPersonaStore* store, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason);
static void __folks_individual_aggregator_personas_changed_cb_folks_persona_store_personas_changed (FolksPersonaStore* _sender, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason, gpointer self);
static void _folks_individual_aggregator_is_primary_store_changed_cb (FolksIndividualAggregator* self, GObject* object, GParamSpec* pspec);
static void __folks_individual_aggregator_is_primary_store_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
static void _folks_individual_aggregator_persona_store_is_quiescent_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec);
static void __folks_individual_aggregator_persona_store_is_quiescent_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
static void _folks_individual_aggregator_persona_store_is_user_set_default_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec);
static void __folks_individual_aggregator_persona_store_is_user_set_default_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
gboolean folks_persona_store_get_is_quiescent (FolksPersonaStore* self);
GeeMap* folks_persona_store_get_personas (FolksPersonaStore* self);
void folks_persona_store_prepare (FolksPersonaStore* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_persona_store_prepare_finish (FolksPersonaStore* self, GAsyncResult* _res_, GError** error);
static void __lambda64_ (Block4Data* _data4_, GObject* obj, GAsyncResult* _result_);
static void ___lambda64__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void _folks_individual_aggregator_emit_individuals_changed (FolksIndividualAggregator* self, GeeSet* added, GeeSet* removed, GeeMultiMap* changes, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason);
gboolean folks_debug_get_debug_output_enabled (FolksDebug* self);
static void _folks_individual_aggregator_connect_to_individual (FolksIndividualAggregator* self, FolksIndividual* individual);
static void _folks_individual_aggregator_individual_removed_cb (FolksIndividualAggregator* self, FolksIndividual* i, FolksIndividual* replacement);
static void __folks_individual_aggregator_individual_removed_cb_folks_individual_removed (FolksIndividual* _sender, FolksIndividual* replacement_individual, gpointer self);
static void _folks_individual_aggregator_disconnect_from_individual (FolksIndividualAggregator* self, FolksIndividual* individual);
static void _folks_individual_aggregator_add_personas (FolksIndividualAggregator* self, GeeSet* added, FolksIndividual** user, GeeHashMultiMap** individuals_changes);
static Block5Data* block5_data_ref (Block5Data* _data5_);
static void block5_data_unref (void * _userdata_);
FolksPersonaStore* folks_persona_get_store (FolksPersona* self);
GType folks_persona_store_trust_get_type (void) G_GNUC_CONST;
FolksPersonaStoreTrust folks_persona_store_get_trust_level (FolksPersonaStore* self);
gboolean folks_individual_has_anti_link_with_persona (FolksIndividual* self, FolksPersona* p);
gchar** folks_persona_get_linkable_properties (FolksPersona* self, int* result_length1);
static Block6Data* block6_data_ref (Block6Data* _data6_);
static void block6_data_unref (void * _userdata_);
void folks_persona_linkable_property_to_links (FolksPersona* self, const gchar* prop_name, FolksPersonaLinkablePropertyCallback callback, void* callback_target);
static void _______lambda62_ (Block6Data* _data6_, const gchar* l);
static void ________lambda62__folks_persona_linkable_property_callback (const gchar* link, gpointer self);
FolksIndividual* folks_individual_new (GeeSet* personas);
FolksIndividual* folks_individual_construct (GType object_type, GeeSet* personas);
static void _folks_individual_aggregator_add_persona_to_link_map (FolksIndividualAggregator* self, FolksPersona* persona, FolksIndividual* individual);
static void _folks_individual_aggregator_remove_individual_from_link_map (FolksIndividualAggregator* self, FolksIndividual* individual);
static void _folks_individual_aggregator_persona_linkable_property_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec);
static void _folks_individual_aggregator_persona_anti_links_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec);
static void _folks_individual_aggregator_connect_to_persona (FolksIndividualAggregator* self, FolksPersona* persona);
static void __folks_individual_aggregator_persona_linkable_property_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
GQuark folks_property_error_quark (void);
GType folks_anti_linkable_get_type (void) G_GNUC_CONST;
static void __folks_individual_aggregator_persona_anti_links_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
static void _folks_individual_aggregator_disconnect_from_persona (FolksIndividualAggregator* self, FolksPersona* persona);
static Block7Data* block7_data_ref (Block7Data* _data7_);
static void block7_data_unref (void * _userdata_);
static void _____lambda63_ (Block7Data* _data7_, const gchar* l);
static void ______lambda63__folks_persona_linkable_property_callback (const gchar* link, gpointer self);
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value);
FolksIndividual* folks_individual_aggregator_get_user (FolksIndividualAggregator* self);
FolksIndividual* folks_persona_get_individual (FolksPersona* self);
void folks_individual_set_personas (FolksIndividual* self, GeeSet* value);
static void folks_individual_aggregator_set_user (FolksIndividualAggregator* self, FolksIndividual* value);
void folks_individual_replace (FolksIndividual* self, FolksIndividual* replacement_individual);
gboolean folks_persona_store_get_is_primary_store (FolksPersonaStore* self);
gboolean folks_persona_store_get_is_user_set_default (FolksPersonaStore* self);
static void folks_individual_aggregator_add_persona_from_details_data_free (gpointer _data);
void folks_individual_aggregator_add_persona_from_details (FolksIndividualAggregator* self, FolksIndividual* parent, FolksPersonaStore* persona_store, GHashTable* details, GAsyncReadyCallback _callback_, gpointer _user_data_);
FolksPersona* folks_individual_aggregator_add_persona_from_details_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_add_persona_from_details_co (FolksIndividualAggregatorAddPersonaFromDetailsData* _data_);
static GHashTable* _folks_individual_aggregator_asv_copy (FolksIndividualAggregator* self, GHashTable* asv);
void folks_persona_store_add_persona_from_details (FolksPersonaStore* self, GHashTable* details, GAsyncReadyCallback _callback_, gpointer _user_data_);
GQuark folks_persona_store_error_quark (void);
FolksPersona* folks_persona_store_add_persona_from_details_finish (FolksPersonaStore* self, GAsyncResult* _res_, GError** error);
static void folks_individual_aggregator_add_persona_from_details_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static Block8Data* block8_data_ref (Block8Data* _data8_);
static void block8_data_unref (void * _userdata_);
static void _g_free0_ (gpointer var);
static void _vala_GValue_free (GValue* self);
static void __vala_GValue_free0_ (gpointer var);
static void __lambda65_ (Block8Data* _data8_, const gchar* k, GValue* v);
static GValue* _g_value_dup (GValue* self);
static void ___lambda65__gh_func (gconstpointer key, gconstpointer value, gpointer self);
static void folks_individual_aggregator_remove_individual_data_free (gpointer _data);
void folks_individual_aggregator_remove_individual (FolksIndividualAggregator* self, FolksIndividual* individual, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_individual_aggregator_remove_individual_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_remove_individual_co (FolksIndividualAggregatorRemoveIndividualData* _data_);
void folks_persona_store_remove_persona (FolksPersonaStore* self, FolksPersona* persona, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_persona_store_remove_persona_finish (FolksPersonaStore* self, GAsyncResult* _res_, GError** error);
static void folks_individual_aggregator_remove_individual_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void folks_individual_aggregator_remove_persona_data_free (gpointer _data);
void folks_individual_aggregator_remove_persona (FolksIndividualAggregator* self, FolksPersona* persona, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_individual_aggregator_remove_persona_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_remove_persona_co (FolksIndividualAggregatorRemovePersonaData* _data_);
static void folks_individual_aggregator_remove_persona_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void folks_individual_aggregator_link_personas_data_free (gpointer _data);
void folks_individual_aggregator_link_personas (FolksIndividualAggregator* self, GeeSet* personas, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_individual_aggregator_link_personas_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_link_personas_co (FolksIndividualAggregatorLinkPersonasData* _data_);
void folks_anti_linkable_remove_anti_links (FolksAntiLinkable* self, GeeSet* other_personas, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_anti_linkable_remove_anti_links_finish (FolksAntiLinkable* self, GAsyncResult* _res_, GError** error);
static void folks_individual_aggregator_link_personas_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static GHashTable* _folks_individual_aggregator_build_linking_details (FolksIndividualAggregator* self, GeeSet* personas);
GType folks_abstract_field_details_get_type (void) G_GNUC_CONST;
guint folks_abstract_field_details_hash (FolksAbstractFieldDetails* self);
gboolean folks_abstract_field_details_equal (FolksAbstractFieldDetails* self, FolksAbstractFieldDetails* that);
GType folks_im_field_details_get_type (void) G_GNUC_CONST;
GType folks_web_service_field_details_get_type (void) G_GNUC_CONST;
GType folks_im_details_get_type (void) G_GNUC_CONST;
GeeMultiMap* folks_im_details_get_im_addresses (FolksImDetails* self);
GType folks_web_service_details_get_type (void) G_GNUC_CONST;
GeeMultiMap* folks_web_service_details_get_web_service_addresses (FolksWebServiceDetails* self);
GType folks_local_id_details_get_type (void) G_GNUC_CONST;
GeeSet* folks_local_id_details_get_local_ids (FolksLocalIdDetails* self);
GType folks_persona_detail_get_type (void) G_GNUC_CONST;
const gchar* folks_persona_store_detail_key (FolksPersonaDetail detail);
static void folks_individual_aggregator_unlink_individual_data_free (gpointer _data);
void folks_individual_aggregator_unlink_individual (FolksIndividualAggregator* self, FolksIndividual* individual, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_individual_aggregator_unlink_individual_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_unlink_individual_co (FolksIndividualAggregatorUnlinkIndividualData* _data_);
static void _folks_individual_aggregator_ensure_personas_property_writeable (FolksIndividualAggregator* self, GeeSet* personas, const gchar* property_name, GAsyncReadyCallback _callback_, gpointer _user_data_);
static FolksPersona* _folks_individual_aggregator_ensure_personas_property_writeable_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static void folks_individual_aggregator_unlink_individual_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
void folks_anti_linkable_add_anti_links (FolksAntiLinkable* self, GeeSet* other_personas, GAsyncReadyCallback _callback_, gpointer _user_data_);
void folks_anti_linkable_add_anti_links_finish (FolksAntiLinkable* self, GAsyncResult* _res_, GError** error);
static void folks_individual_aggregator_ensure_individual_property_writeable_data_free (gpointer _data);
void folks_individual_aggregator_ensure_individual_property_writeable (FolksIndividualAggregator* self, FolksIndividual* individual, const gchar* property_name, GAsyncReadyCallback _callback_, gpointer _user_data_);
FolksPersona* folks_individual_aggregator_ensure_individual_property_writeable_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_ensure_individual_property_writeable_co (FolksIndividualAggregatorEnsureIndividualPropertyWriteableData* _data_);
static void folks_individual_aggregator_ensure_individual_property_writeable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _folks_individual_aggregator_ensure_personas_property_writeable_data_free (gpointer _data);
static gboolean _folks_individual_aggregator_ensure_personas_property_writeable_co (FolksIndividualAggregatorEnsurePersonasPropertyWriteableData* _data_);
gchar** folks_persona_get_writeable_properties (FolksPersona* self, int* result_length1);
static gboolean _vala_string_array_contains (gchar** stack, int stack_length, gchar* needle);
gchar** folks_persona_store_get_always_writeable_properties (FolksPersonaStore* self, int* result_length1);
static void _folks_individual_aggregator_ensure_personas_property_writeable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void folks_individual_aggregator_look_up_individual_data_free (gpointer _data);
void folks_individual_aggregator_look_up_individual (FolksIndividualAggregator* self, const gchar* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
FolksIndividual* folks_individual_aggregator_look_up_individual_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error);
static gboolean folks_individual_aggregator_look_up_individual_co (FolksIndividualAggregatorLookUpIndividualData* _data_);
static void folks_individual_aggregator_look_up_individual_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
gboolean folks_individual_aggregator_get_is_prepared (FolksIndividualAggregator* self);
gboolean folks_individual_aggregator_get_is_quiescent (FolksIndividualAggregator* self);
FolksPersonaStore* folks_individual_aggregator_get_primary_store (FolksIndividualAggregator* self);
static void folks_individual_aggregator_set_individuals (FolksIndividualAggregator* self, GeeMap* value);
static void g_cclosure_user_marshal_VOID__OBJECT_OBJECT_STRING_OBJECT_ENUM (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
static GObject * folks_individual_aggregator_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
FolksDebug* folks_debug_dup (void);
FolksBackendStore* folks_backend_store_dup (void);
static void folks_individual_aggregator_finalize (GObject* obj);
static void _vala_folks_individual_aggregator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
static void _vala_folks_individual_aggregator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
static gint _vala_array_length (gpointer array);


GQuark folks_individual_aggregator_error_quark (void) {
	return g_quark_from_static_string ("folks_individual_aggregator_error-quark");
}


static void __folks_individual_aggregator_backend_available_cb_folks_backend_store_backend_available (FolksBackendStore* _sender, FolksBackend* backend, gpointer self) {
	_folks_individual_aggregator_backend_available_cb (self, _sender, backend);
}


static void __folks_individual_aggregator_debug_print_status_folks_debug_print_status (FolksDebug* _sender, gpointer self) {
	_folks_individual_aggregator_debug_print_status (self, _sender);
}


/**
   * Create a new IndividualAggregator.
   *
   * Clients should connect to the
   * {@link IndividualAggregator.individuals_changed} signal (or the
   * {@link IndividualAggregator.individuals_changed_detailed} signal), then
   * call {@link IndividualAggregator.prepare} to load the backends and start
   * aggregating individuals.
   *
   * An example of how to set up an IndividualAggregator:
   * {{{
   *   IndividualAggregator agg = new IndividualAggregator ();
   *   agg.individuals_changed_detailed.connect (individuals_changed_cb);
   *   agg.prepare ();
   * }}}
   */
FolksIndividualAggregator* folks_individual_aggregator_construct (GType object_type) {
	FolksIndividualAggregator * self = NULL;
	self = (FolksIndividualAggregator*) g_object_new (object_type, NULL);
	return self;
}


FolksIndividualAggregator* folks_individual_aggregator_new (void) {
	return folks_individual_aggregator_construct (FOLKS_TYPE_INDIVIDUAL_AGGREGATOR);
}


static gint string_index_of (const gchar* self, const gchar* needle, gint start_index) {
	gint result = 0;
	gint _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_ = NULL;
	gchar* _result_;
	gchar* _tmp3_;
	g_return_val_if_fail (self != NULL, 0);
	g_return_val_if_fail (needle != NULL, 0);
	_tmp0_ = start_index;
	_tmp1_ = needle;
	_tmp2_ = strstr (((gchar*) self) + _tmp0_, (gchar*) _tmp1_);
	_result_ = _tmp2_;
	_tmp3_ = _result_;
	if (_tmp3_ != NULL) {
		gchar* _tmp4_;
		_tmp4_ = _result_;
		result = (gint) (_tmp4_ - ((gchar*) self));
		return result;
	} else {
		result = -1;
		return result;
	}
}


static void _folks_individual_aggregator_configure_primary_store (FolksIndividualAggregator* self, const gchar* store_config_ids) {
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	gint _tmp2_ = 0;
	g_return_if_fail (self != NULL);
	g_return_if_fail (store_config_ids != NULL);
	_tmp0_ = store_config_ids;
	g_debug ("individual-aggregator.vala:373: _configure_primary_store to '%s'", _tmp0_);
	self->priv->_user_configured_primary_store = TRUE;
	_tmp1_ = store_config_ids;
	_tmp2_ = string_index_of (_tmp1_, ":", 0);
	if (_tmp2_ != (-1)) {
		const gchar* _tmp3_;
		gchar** _tmp4_;
		gchar** _tmp5_ = NULL;
		gchar** ids;
		gint ids_length1;
		gint _ids_size_;
		gchar** _tmp6_;
		gint _tmp6__length1;
		const gchar* _tmp7_;
		gchar* _tmp8_;
		gchar** _tmp9_;
		gint _tmp9__length1;
		const gchar* _tmp10_;
		gchar* _tmp11_;
		_tmp3_ = store_config_ids;
		_tmp5_ = _tmp4_ = g_strsplit (_tmp3_, ":", 2);
		ids = _tmp5_;
		ids_length1 = _vala_array_length (_tmp4_);
		_ids_size_ = ids_length1;
		_tmp6_ = ids;
		_tmp6__length1 = ids_length1;
		_tmp7_ = _tmp6_[0];
		_tmp8_ = g_strdup (_tmp7_);
		_g_free0 (self->priv->_configured_primary_store_type_id);
		self->priv->_configured_primary_store_type_id = _tmp8_;
		_tmp9_ = ids;
		_tmp9__length1 = ids_length1;
		_tmp10_ = _tmp9_[1];
		_tmp11_ = g_strdup (_tmp10_);
		_g_free0 (self->priv->_configured_primary_store_id);
		self->priv->_configured_primary_store_id = _tmp11_;
		ids = (_vala_array_free (ids, ids_length1, (GDestroyNotify) g_free), NULL);
	} else {
		const gchar* _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		_tmp12_ = store_config_ids;
		_tmp13_ = g_strdup (_tmp12_);
		_g_free0 (self->priv->_configured_primary_store_type_id);
		self->priv->_configured_primary_store_type_id = _tmp13_;
		_tmp14_ = g_strdup ("");
		_g_free0 (self->priv->_configured_primary_store_id);
		self->priv->_configured_primary_store_id = _tmp14_;
	}
}


static void _folks_individual_aggregator_debug_print_status (FolksIndividualAggregator* self, FolksDebug* debug) {
	static const char domain[] = FOLKS_DEBUG_STATUS_LOG_DOMAIN;
	static const GLogLevelFlags level = G_LOG_LEVEL_INFO;
	FolksDebug* _tmp0_;
	const gchar* _tmp1_ = NULL;
	gboolean _tmp2_;
	const gchar* _tmp3_ = NULL;
	gboolean _tmp4_;
	gchar* _tmp5_ = NULL;
	gboolean _tmp6_;
	FolksDebug* _tmp11_;
	guint _tmp12_;
	gchar* _tmp13_ = NULL;
	gchar* _tmp14_;
	FolksPersonaStore* _tmp15_;
	gchar* _tmp16_ = NULL;
	gchar* _tmp17_;
	const gchar* _tmp18_;
	const gchar* _tmp19_;
	const gchar* _tmp20_;
	const gchar* _tmp21_;
	const gchar* _tmp22_;
	FolksDebug* _tmp23_;
	GeeMap* _tmp24_;
	GeeMap* _tmp25_;
	gint _tmp26_;
	gint _tmp27_;
	FolksDebug* _tmp28_;
	FolksDebug* _tmp98_;
	FolksDebug* _tmp99_;
	GeeHashMultiMap* _tmp100_;
	gint _tmp101_;
	gint _tmp102_;
	FolksDebug* _tmp103_;
	FolksDebug* _tmp130_;
	FolksDebug* _tmp131_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (debug != NULL);
	_tmp0_ = debug;
	folks_debug_print_heading (_tmp0_, domain, level, "IndividualAggregator (%p)", self);
	_tmp2_ = self->priv->_linking_enabled;
	if (_tmp2_) {
		_tmp1_ = "yes";
	} else {
		_tmp1_ = "no";
	}
	_tmp4_ = self->priv->_is_prepared;
	if (_tmp4_) {
		_tmp3_ = "yes";
	} else {
		_tmp3_ = "no";
	}
	_tmp6_ = self->priv->_is_quiescent;
	if (_tmp6_) {
		gchar* _tmp7_;
		_tmp7_ = g_strdup ("yes");
		_g_free0 (_tmp5_);
		_tmp5_ = _tmp7_;
	} else {
		guint _tmp8_;
		guint _tmp9_;
		gchar* _tmp10_ = NULL;
		_tmp8_ = self->priv->_non_quiescent_backend_count;
		_tmp9_ = self->priv->_non_quiescent_persona_store_count;
		_tmp10_ = g_strdup_printf ("no (%u backends, %u persona stores left)", _tmp8_, _tmp9_);
		_g_free0 (_tmp5_);
		_tmp5_ = _tmp10_;
	}
	_tmp11_ = debug;
	_tmp12_ = ((GObject*) self)->ref_count;
	_tmp13_ = g_strdup_printf ("%u", _tmp12_);
	_tmp14_ = _tmp13_;
	_tmp15_ = self->priv->_primary_store;
	_tmp16_ = g_strdup_printf ("%p", _tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = self->priv->_configured_primary_store_type_id;
	_tmp19_ = self->priv->_configured_primary_store_id;
	_tmp20_ = _tmp1_;
	_tmp21_ = _tmp3_;
	_tmp22_ = _tmp5_;
	folks_debug_print_key_value_pairs (_tmp11_, domain, level, "Ref. count", _tmp14_, "Primary store", _tmp17_, "Configured store type id", _tmp18_, "Configured store id", _tmp19_, "Linking enabled?", _tmp20_, "Prepared?", _tmp21_, "Quiescent?", _tmp22_, NULL);
	_g_free0 (_tmp17_);
	_g_free0 (_tmp14_);
	_tmp23_ = debug;
	_tmp24_ = folks_individual_aggregator_get_individuals (self);
	_tmp25_ = _tmp24_;
	_tmp26_ = gee_map_get_size (_tmp25_);
	_tmp27_ = _tmp26_;
	folks_debug_print_line (_tmp23_, domain, level, "%u Individuals:", (guint) _tmp27_);
	_tmp28_ = debug;
	folks_debug_indent (_tmp28_);
	{
		GeeMap* _tmp29_;
		GeeMap* _tmp30_;
		GeeCollection* _tmp31_;
		GeeCollection* _tmp32_;
		GeeCollection* _tmp33_;
		GeeIterator* _tmp34_ = NULL;
		GeeIterator* _tmp35_;
		GeeIterator* _individual_it;
		_tmp29_ = folks_individual_aggregator_get_individuals (self);
		_tmp30_ = _tmp29_;
		_tmp31_ = gee_map_get_values (_tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = _tmp32_;
		_tmp34_ = gee_iterable_iterator ((GeeIterable*) _tmp33_);
		_tmp35_ = _tmp34_;
		_g_object_unref0 (_tmp33_);
		_individual_it = _tmp35_;
		while (TRUE) {
			GeeIterator* _tmp36_;
			gboolean _tmp37_ = FALSE;
			GeeIterator* _tmp38_;
			gpointer _tmp39_ = NULL;
			FolksIndividual* individual;
			gchar* trust_level;
			FolksIndividual* _tmp40_;
			FolksTrustLevel _tmp41_;
			FolksTrustLevel _tmp42_;
			FolksDebug* _tmp45_;
			FolksIndividual* _tmp46_;
			const gchar* _tmp47_ = NULL;
			FolksIndividual* _tmp48_;
			gboolean _tmp49_;
			gboolean _tmp50_;
			FolksDebug* _tmp51_;
			FolksIndividual* _tmp52_;
			guint _tmp53_;
			gchar* _tmp54_ = NULL;
			gchar* _tmp55_;
			FolksIndividual* _tmp56_;
			const gchar* _tmp57_;
			const gchar* _tmp58_;
			const gchar* _tmp59_;
			const gchar* _tmp60_;
			FolksDebug* _tmp61_;
			FolksIndividual* _tmp62_;
			GeeSet* _tmp63_;
			GeeSet* _tmp64_;
			gint _tmp65_;
			gint _tmp66_;
			FolksDebug* _tmp67_;
			FolksDebug* _tmp97_;
			_tmp36_ = _individual_it;
			_tmp37_ = gee_iterator_next (_tmp36_);
			if (!_tmp37_) {
				break;
			}
			_tmp38_ = _individual_it;
			_tmp39_ = gee_iterator_get (_tmp38_);
			individual = (FolksIndividual*) _tmp39_;
			trust_level = NULL;
			_tmp40_ = individual;
			_tmp41_ = folks_individual_get_trust_level (_tmp40_);
			_tmp42_ = _tmp41_;
			switch (_tmp42_) {
				case FOLKS_TRUST_LEVEL_NONE:
				{
					gchar* _tmp43_;
					_tmp43_ = g_strdup ("none");
					_g_free0 (trust_level);
					trust_level = _tmp43_;
					break;
				}
				case FOLKS_TRUST_LEVEL_PERSONAS:
				{
					gchar* _tmp44_;
					_tmp44_ = g_strdup ("personas");
					_g_free0 (trust_level);
					trust_level = _tmp44_;
					break;
				}
				default:
				{
					g_assert_not_reached ();
				}
			}
			_tmp45_ = debug;
			_tmp46_ = individual;
			folks_debug_print_heading (_tmp45_, domain, level, "Individual (%p)", _tmp46_);
			_tmp48_ = individual;
			_tmp49_ = folks_individual_get_is_user (_tmp48_);
			_tmp50_ = _tmp49_;
			if (_tmp50_) {
				_tmp47_ = "yes";
			} else {
				_tmp47_ = "no";
			}
			_tmp51_ = debug;
			_tmp52_ = individual;
			_tmp53_ = ((GObject*) _tmp52_)->ref_count;
			_tmp54_ = g_strdup_printf ("%u", _tmp53_);
			_tmp55_ = _tmp54_;
			_tmp56_ = individual;
			_tmp57_ = folks_individual_get_id (_tmp56_);
			_tmp58_ = _tmp57_;
			_tmp59_ = _tmp47_;
			_tmp60_ = trust_level;
			folks_debug_print_key_value_pairs (_tmp51_, domain, level, "Ref. count", _tmp55_, "ID", _tmp58_, "User?", _tmp59_, "Trust level", _tmp60_, NULL);
			_g_free0 (_tmp55_);
			_tmp61_ = debug;
			_tmp62_ = individual;
			_tmp63_ = folks_individual_get_personas (_tmp62_);
			_tmp64_ = _tmp63_;
			_tmp65_ = gee_collection_get_size ((GeeCollection*) _tmp64_);
			_tmp66_ = _tmp65_;
			folks_debug_print_line (_tmp61_, domain, level, "%u Personas:", (guint) _tmp66_);
			_tmp67_ = debug;
			folks_debug_indent (_tmp67_);
			{
				FolksIndividual* _tmp68_;
				GeeSet* _tmp69_;
				GeeSet* _tmp70_;
				GeeIterator* _tmp71_ = NULL;
				GeeIterator* _persona_it;
				_tmp68_ = individual;
				_tmp69_ = folks_individual_get_personas (_tmp68_);
				_tmp70_ = _tmp69_;
				_tmp71_ = gee_iterable_iterator ((GeeIterable*) _tmp70_);
				_persona_it = _tmp71_;
				while (TRUE) {
					GeeIterator* _tmp72_;
					gboolean _tmp73_ = FALSE;
					GeeIterator* _tmp74_;
					gpointer _tmp75_ = NULL;
					FolksPersona* persona;
					FolksDebug* _tmp76_;
					FolksPersona* _tmp77_;
					const gchar* _tmp78_ = NULL;
					FolksPersona* _tmp79_;
					gboolean _tmp80_;
					gboolean _tmp81_;
					FolksDebug* _tmp82_;
					FolksPersona* _tmp83_;
					guint _tmp84_;
					gchar* _tmp85_ = NULL;
					gchar* _tmp86_;
					FolksPersona* _tmp87_;
					const gchar* _tmp88_;
					const gchar* _tmp89_;
					FolksPersona* _tmp90_;
					const gchar* _tmp91_;
					const gchar* _tmp92_;
					FolksPersona* _tmp93_;
					const gchar* _tmp94_;
					const gchar* _tmp95_;
					const gchar* _tmp96_;
					_tmp72_ = _persona_it;
					_tmp73_ = gee_iterator_next (_tmp72_);
					if (!_tmp73_) {
						break;
					}
					_tmp74_ = _persona_it;
					_tmp75_ = gee_iterator_get (_tmp74_);
					persona = (FolksPersona*) _tmp75_;
					_tmp76_ = debug;
					_tmp77_ = persona;
					folks_debug_print_heading (_tmp76_, domain, level, "Persona (%p)", _tmp77_);
					_tmp79_ = persona;
					_tmp80_ = folks_persona_get_is_user (_tmp79_);
					_tmp81_ = _tmp80_;
					if (_tmp81_) {
						_tmp78_ = "yes";
					} else {
						_tmp78_ = "no";
					}
					_tmp82_ = debug;
					_tmp83_ = persona;
					_tmp84_ = ((GObject*) _tmp83_)->ref_count;
					_tmp85_ = g_strdup_printf ("%u", _tmp84_);
					_tmp86_ = _tmp85_;
					_tmp87_ = persona;
					_tmp88_ = folks_persona_get_uid (_tmp87_);
					_tmp89_ = _tmp88_;
					_tmp90_ = persona;
					_tmp91_ = folks_persona_get_iid (_tmp90_);
					_tmp92_ = _tmp91_;
					_tmp93_ = persona;
					_tmp94_ = folks_persona_get_display_id (_tmp93_);
					_tmp95_ = _tmp94_;
					_tmp96_ = _tmp78_;
					folks_debug_print_key_value_pairs (_tmp82_, domain, level, "Ref. count", _tmp86_, "UID", _tmp89_, "IID", _tmp92_, "Display ID", _tmp95_, "User?", _tmp96_, NULL);
					_g_free0 (_tmp86_);
					_g_object_unref0 (persona);
				}
				_g_object_unref0 (_persona_it);
			}
			_tmp97_ = debug;
			folks_debug_unindent (_tmp97_);
			_g_free0 (trust_level);
			_g_object_unref0 (individual);
		}
		_g_object_unref0 (_individual_it);
	}
	_tmp98_ = debug;
	folks_debug_unindent (_tmp98_);
	_tmp99_ = debug;
	_tmp100_ = self->priv->_link_map;
	_tmp101_ = gee_multi_map_get_size ((GeeMultiMap*) _tmp100_);
	_tmp102_ = _tmp101_;
	folks_debug_print_line (_tmp99_, domain, level, "%u entries in the link map:", (guint) _tmp102_);
	_tmp103_ = debug;
	folks_debug_indent (_tmp103_);
	{
		GeeHashMultiMap* _tmp104_;
		GeeSet* _tmp105_ = NULL;
		GeeSet* _tmp106_;
		GeeIterator* _tmp107_ = NULL;
		GeeIterator* _tmp108_;
		GeeIterator* _link_key_it;
		_tmp104_ = self->priv->_link_map;
		_tmp105_ = gee_multi_map_get_keys ((GeeMultiMap*) _tmp104_);
		_tmp106_ = _tmp105_;
		_tmp107_ = gee_iterable_iterator ((GeeIterable*) _tmp106_);
		_tmp108_ = _tmp107_;
		_g_object_unref0 (_tmp106_);
		_link_key_it = _tmp108_;
		while (TRUE) {
			GeeIterator* _tmp109_;
			gboolean _tmp110_ = FALSE;
			GeeIterator* _tmp111_;
			gpointer _tmp112_ = NULL;
			gchar* link_key;
			FolksDebug* _tmp113_;
			const gchar* _tmp114_;
			FolksDebug* _tmp115_;
			FolksDebug* _tmp128_;
			FolksDebug* _tmp129_;
			_tmp109_ = _link_key_it;
			_tmp110_ = gee_iterator_next (_tmp109_);
			if (!_tmp110_) {
				break;
			}
			_tmp111_ = _link_key_it;
			_tmp112_ = gee_iterator_get (_tmp111_);
			link_key = (gchar*) _tmp112_;
			_tmp113_ = debug;
			_tmp114_ = link_key;
			folks_debug_print_line (_tmp113_, domain, level, "%s → {", _tmp114_);
			_tmp115_ = debug;
			folks_debug_indent (_tmp115_);
			{
				GeeHashMultiMap* _tmp116_;
				const gchar* _tmp117_;
				GeeCollection* _tmp118_ = NULL;
				GeeCollection* _tmp119_;
				GeeIterator* _tmp120_ = NULL;
				GeeIterator* _tmp121_;
				GeeIterator* _individual_it;
				_tmp116_ = self->priv->_link_map;
				_tmp117_ = link_key;
				_tmp118_ = gee_multi_map_get ((GeeMultiMap*) _tmp116_, _tmp117_);
				_tmp119_ = _tmp118_;
				_tmp120_ = gee_iterable_iterator ((GeeIterable*) _tmp119_);
				_tmp121_ = _tmp120_;
				_g_object_unref0 (_tmp119_);
				_individual_it = _tmp121_;
				while (TRUE) {
					GeeIterator* _tmp122_;
					gboolean _tmp123_ = FALSE;
					GeeIterator* _tmp124_;
					gpointer _tmp125_ = NULL;
					FolksIndividual* individual;
					FolksDebug* _tmp126_;
					FolksIndividual* _tmp127_;
					_tmp122_ = _individual_it;
					_tmp123_ = gee_iterator_next (_tmp122_);
					if (!_tmp123_) {
						break;
					}
					_tmp124_ = _individual_it;
					_tmp125_ = gee_iterator_get (_tmp124_);
					individual = (FolksIndividual*) _tmp125_;
					_tmp126_ = debug;
					_tmp127_ = individual;
					folks_debug_print_line (_tmp126_, domain, level, "%p", _tmp127_);
					_g_object_unref0 (individual);
				}
				_g_object_unref0 (_individual_it);
			}
			_tmp128_ = debug;
			folks_debug_unindent (_tmp128_);
			_tmp129_ = debug;
			folks_debug_print_line (_tmp129_, domain, level, "}");
			_g_free0 (link_key);
		}
		_g_object_unref0 (_link_key_it);
	}
	_tmp130_ = debug;
	folks_debug_unindent (_tmp130_);
	_tmp131_ = debug;
	folks_debug_print_line (_tmp131_, domain, level, "");
	_g_free0 (_tmp5_);
}


static void folks_individual_aggregator_prepare_data_free (gpointer _data) {
	FolksIndividualAggregatorPrepareData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorPrepareData, _data_);
}


static gpointer _g_object_ref0 (gpointer self) {
	return self ? g_object_ref (self) : NULL;
}


void folks_individual_aggregator_prepare (FolksIndividualAggregator* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorPrepareData* _data_;
	FolksIndividualAggregator* _tmp0_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorPrepareData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_prepare);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_prepare_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	folks_individual_aggregator_prepare_co (_data_);
}


void folks_individual_aggregator_prepare_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividualAggregatorPrepareData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


/**
   * Prepare the IndividualAggregator for use.
   *
   * This loads all the available backends and prepares them for use by the
   * IndividualAggregator. This should be called //after// connecting to the
   * {@link IndividualAggregator.individuals_changed} signal (or
   * {@link IndividualAggregator.individuals_changed_detailed} signal), or a
   * race condition could occur, with the signal being emitted before your code
   * has connected to them, and {@link Individual}s getting "lost" as a result.
   *
   * This function is guaranteed to be idempotent (since version 0.3.0).
   *
   * Concurrent calls to this function from different threads will block until
   * preparation has completed. However, concurrent calls to this function from
   * a single thread might not, i.e. the first call will block but subsequent
   * calls might return before the first one. (Though they will be safe in every
   * other respect.)
   *
   * @throws GLib.Error if preparing any of the backends failed — this error
   * will be passed through from {@link BackendStore.load_backends}
   *
   * @since 0.1.11
   */
static void folks_individual_aggregator_prepare_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorPrepareData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_prepare_co (_data_);
}


static gboolean folks_individual_aggregator_prepare_co (FolksIndividualAggregatorPrepareData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	folks_internal_profiling_start ("preparing IndividualAggregator", NULL);
	_data_->_tmp1_ = _data_->self->priv->_is_prepared;
	if (_data_->_tmp1_) {
		_data_->_tmp0_ = TRUE;
	} else {
		_data_->_tmp2_ = _data_->self->priv->_prepare_pending;
		_data_->_tmp0_ = _data_->_tmp2_;
	}
	_data_->_tmp3_ = _data_->_tmp0_;
	if (_data_->_tmp3_) {
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	{
		_data_->self->priv->_prepare_pending = TRUE;
		_data_->_tmp4_ = _data_->self->priv->_non_quiescent_backend_count;
		_data_->self->priv->_non_quiescent_backend_count = _data_->_tmp4_ + 1;
		_data_->_tmp5_ = _data_->self->priv->_backend_store;
		g_signal_connect_object (_data_->_tmp5_, "backend-available", (GCallback) __folks_individual_aggregator_backend_available_cb_folks_backend_store_backend_available, _data_->self, 0);
		_data_->_tmp6_ = _data_->self->priv->_backend_store;
		_data_->_tmp7_ = folks_backend_store_get_enabled_backends (_data_->_tmp6_);
		_data_->_tmp8_ = _data_->_tmp7_;
		_data_->_tmp9_ = gee_map_get_values (_data_->_tmp8_);
		_data_->_tmp10_ = _data_->_tmp9_;
		_data_->backends = _data_->_tmp10_;
		{
			_data_->_tmp11_ = _data_->backends;
			_data_->_tmp12_ = NULL;
			_data_->_tmp12_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp11_);
			_data_->_backend_it = _data_->_tmp12_;
			while (TRUE) {
				_data_->_tmp13_ = _data_->_backend_it;
				_data_->_tmp14_ = FALSE;
				_data_->_tmp14_ = gee_iterator_next (_data_->_tmp13_);
				if (!_data_->_tmp14_) {
					break;
				}
				_data_->_tmp15_ = _data_->_backend_it;
				_data_->_tmp16_ = NULL;
				_data_->_tmp16_ = gee_iterator_get (_data_->_tmp15_);
				_data_->backend = (FolksBackend*) _data_->_tmp16_;
				_data_->_tmp17_ = _data_->self->priv->_backend_store;
				_data_->_tmp18_ = _data_->backend;
				_folks_individual_aggregator_backend_available_cb (_data_->self, _data_->_tmp17_, _data_->_tmp18_);
				_g_object_unref0 (_data_->backend);
			}
			_g_object_unref0 (_data_->_backend_it);
		}
		_data_->_tmp19_ = _data_->self->priv->_backend_store;
		_data_->_state_ = 1;
		folks_backend_store_load_backends (_data_->_tmp19_, folks_individual_aggregator_prepare_ready, _data_);
		return FALSE;
		_state_1:
		folks_backend_store_load_backends_finish (_data_->_tmp19_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			_g_object_unref0 (_data_->backends);
			goto __finally14;
		}
		_data_->_tmp20_ = _data_->self->priv->_non_quiescent_backend_count;
		_data_->self->priv->_non_quiescent_backend_count = _data_->_tmp20_ - 1;
		_data_->self->priv->_is_prepared = TRUE;
		_data_->self->priv->_prepare_pending = FALSE;
		g_object_notify ((GObject*) _data_->self, "is-prepared");
		_data_->_tmp21_ = _data_->self->priv->_is_quiescent;
		if (_data_->_tmp21_ == FALSE) {
			_folks_individual_aggregator_notify_if_is_quiescent (_data_->self);
		}
		_g_object_unref0 (_data_->backends);
	}
	__finally14:
	{
		_data_->self->priv->_prepare_pending = FALSE;
	}
	if (_data_->_inner_error_ != NULL) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	folks_internal_profiling_end ("preparing IndividualAggregator", NULL);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void folks_individual_aggregator_unprepare_data_free (gpointer _data) {
	FolksIndividualAggregatorUnprepareData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorUnprepareData, _data_);
}


void folks_individual_aggregator_unprepare (FolksIndividualAggregator* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorUnprepareData* _data_;
	FolksIndividualAggregator* _tmp0_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorUnprepareData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_unprepare);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_unprepare_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	folks_individual_aggregator_unprepare_co (_data_);
}


void folks_individual_aggregator_unprepare_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividualAggregatorUnprepareData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


/**
   * Clean up and release resources used by the aggregator.
   *
   * This will disconnect the aggregator cleanly from any resources it or its
   * persona stores are using. It is recommended to call this method before
   * finalising the individual aggregator, but calling it is not required. If
   * this method is not called then, for example, unsaved changes in backends
   * may not be flushed.
   *
   * Concurrent calls to this function from different threads will block until
   * preparation has completed. However, concurrent calls to this function from
   * a single thread might not, i.e. the first call will block but subsequent
   * calls might return before the first one. (Though they will be safe in every
   * other respect.)
   *
   * @since 0.7.3
   * @throws GLib.Error if unpreparing the backend-specific services failed —
   * this will be a backend-specific error
   */
static void folks_individual_aggregator_unprepare_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorUnprepareData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_unprepare_co (_data_);
}


static gboolean folks_individual_aggregator_unprepare_co (FolksIndividualAggregatorUnprepareData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	{
		_data_->_tmp0_ = _data_->self->priv->_is_prepared;
		g_static_rec_mutex_lock (&_data_->self->priv->__lock__is_prepared);
		{
			_data_->_tmp2_ = _data_->self->priv->_is_prepared;
			if (!_data_->_tmp2_) {
				_data_->_tmp1_ = TRUE;
			} else {
				_data_->_tmp3_ = _data_->self->priv->_prepare_pending;
				_data_->_tmp1_ = _data_->_tmp3_;
			}
			_data_->_tmp4_ = _data_->_tmp1_;
			if (_data_->_tmp4_) {
				{
					_data_->_tmp5_ = _data_->self->priv->_is_prepared;
					g_static_rec_mutex_unlock (&_data_->self->priv->__lock__is_prepared);
				}
				if (_data_->_state_ == 0) {
					g_simple_async_result_complete_in_idle (_data_->_async_result);
				} else {
					g_simple_async_result_complete (_data_->_async_result);
				}
				g_object_unref (_data_->_async_result);
				return FALSE;
			}
			{
				{
					_data_->_tmp6_ = _data_->self->priv->_stores;
					_data_->_tmp7_ = gee_abstract_map_get_values ((GeeMap*) _data_->_tmp6_);
					_data_->_tmp8_ = _data_->_tmp7_;
					_data_->_tmp9_ = _data_->_tmp8_;
					_data_->_tmp10_ = NULL;
					_data_->_tmp10_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp9_);
					_data_->_tmp11_ = _data_->_tmp10_;
					_g_object_unref0 (_data_->_tmp9_);
					_data_->_p_it = _data_->_tmp11_;
					while (TRUE) {
						_data_->_tmp12_ = _data_->_p_it;
						_data_->_tmp13_ = FALSE;
						_data_->_tmp13_ = gee_iterator_next (_data_->_tmp12_);
						if (!_data_->_tmp13_) {
							break;
						}
						_data_->_tmp14_ = _data_->_p_it;
						_data_->_tmp15_ = NULL;
						_data_->_tmp15_ = gee_iterator_get (_data_->_tmp14_);
						_data_->p = (FolksPersonaStore*) _data_->_tmp15_;
						_data_->_tmp16_ = _data_->p;
						_data_->_state_ = 1;
						folks_persona_store_flush (_data_->_tmp16_, folks_individual_aggregator_unprepare_ready, _data_);
						return FALSE;
						_state_1:
						folks_persona_store_flush_finish (_data_->_tmp16_, _data_->_res_);
						_g_object_unref0 (_data_->p);
					}
					_g_object_unref0 (_data_->_p_it);
				}
			}
			__finally16:
			{
				_data_->self->priv->_prepare_pending = FALSE;
			}
			if (_data_->_inner_error_ != NULL) {
				{
					_data_->_tmp17_ = _data_->self->priv->_is_prepared;
					g_static_rec_mutex_unlock (&_data_->self->priv->__lock__is_prepared);
				}
				g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
				g_clear_error (&_data_->_inner_error_);
				return FALSE;
			}
		}
		__finally15:
		{
			_data_->_tmp18_ = _data_->self->priv->_is_prepared;
			g_static_rec_mutex_unlock (&_data_->self->priv->__lock__is_prepared);
		}
		if (_data_->_inner_error_ != NULL) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		}
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


/**
   * Get all matches for a given {@link Individual}.
   *
   * @param matchee the individual to find matches for
   * @param min_threshold the threshold for accepting a match
   * @return a map from matched individuals to the degree with which they match
   * ``matchee`` (which is guaranteed to at least equal ``min_threshold``);
   * if no matches could be found, an empty map is returned
   *
   * @since 0.5.1
   */
GeeMap* folks_individual_aggregator_get_potential_matches (FolksIndividualAggregator* self, FolksIndividual* matchee, FolksMatchResult min_threshold) {
	GeeMap* result = NULL;
	GeeHashMap* _tmp0_;
	GeeHashMap* matches;
	FolksPotentialMatch* _tmp1_;
	FolksPotentialMatch* matchObj;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (matchee != NULL, NULL);
	_tmp0_ = gee_hash_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_MATCH_RESULT, NULL, NULL, NULL, NULL, NULL);
	matches = _tmp0_;
	_tmp1_ = folks_potential_match_new ();
	matchObj = _tmp1_;
	{
		GeeMap* _tmp2_;
		GeeCollection* _tmp3_;
		GeeCollection* _tmp4_;
		GeeCollection* _tmp5_;
		GeeIterator* _tmp6_ = NULL;
		GeeIterator* _tmp7_;
		GeeIterator* _i_it;
		_tmp2_ = self->priv->_individuals;
		_tmp3_ = gee_map_get_values (_tmp2_);
		_tmp4_ = _tmp3_;
		_tmp5_ = _tmp4_;
		_tmp6_ = gee_iterable_iterator ((GeeIterable*) _tmp5_);
		_tmp7_ = _tmp6_;
		_g_object_unref0 (_tmp5_);
		_i_it = _tmp7_;
		while (TRUE) {
			GeeIterator* _tmp8_;
			gboolean _tmp9_ = FALSE;
			GeeIterator* _tmp10_;
			gpointer _tmp11_ = NULL;
			FolksIndividual* i;
			FolksIndividual* _tmp12_;
			const gchar* _tmp13_;
			const gchar* _tmp14_;
			FolksIndividual* _tmp15_;
			const gchar* _tmp16_;
			const gchar* _tmp17_;
			FolksPotentialMatch* _tmp18_;
			FolksIndividual* _tmp19_;
			FolksIndividual* _tmp20_;
			FolksMatchResult _tmp21_ = 0;
			FolksMatchResult _result_;
			FolksMatchResult _tmp22_;
			FolksMatchResult _tmp23_;
			_tmp8_ = _i_it;
			_tmp9_ = gee_iterator_next (_tmp8_);
			if (!_tmp9_) {
				break;
			}
			_tmp10_ = _i_it;
			_tmp11_ = gee_iterator_get (_tmp10_);
			i = (FolksIndividual*) _tmp11_;
			_tmp12_ = i;
			_tmp13_ = folks_individual_get_id (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp15_ = matchee;
			_tmp16_ = folks_individual_get_id (_tmp15_);
			_tmp17_ = _tmp16_;
			if (g_strcmp0 (_tmp14_, _tmp17_) == 0) {
				_g_object_unref0 (i);
				continue;
			}
			_tmp18_ = matchObj;
			_tmp19_ = i;
			_tmp20_ = matchee;
			_tmp21_ = folks_potential_match_potential_match (_tmp18_, _tmp19_, _tmp20_);
			_result_ = _tmp21_;
			_tmp22_ = _result_;
			_tmp23_ = min_threshold;
			if (_tmp22_ >= _tmp23_) {
				GeeHashMap* _tmp24_;
				FolksIndividual* _tmp25_;
				FolksMatchResult _tmp26_;
				_tmp24_ = matches;
				_tmp25_ = i;
				_tmp26_ = _result_;
				gee_abstract_map_set ((GeeAbstractMap*) _tmp24_, _tmp25_, (gpointer) ((gintptr) _tmp26_));
			}
			_g_object_unref0 (i);
		}
		_g_object_unref0 (_i_it);
	}
	result = (GeeMap*) matches;
	_g_object_unref0 (matchObj);
	return result;
}


/**
   * Get all combinations between all {@link Individual}s.
   *
   * @param min_threshold the threshold for accepting a match
   * @return a map from each individual in the aggregator to a map of the
   * other individuals in the aggregator which can be matched with that
   * individual, mapped to the degree with which they match the original
   * individual (which is guaranteed to at least equal ``min_threshold``)
   *
   * @since 0.5.1
   */
GeeMap* folks_individual_aggregator_get_all_potential_matches (FolksIndividualAggregator* self, FolksMatchResult min_threshold) {
	GeeMap* result = NULL;
	GeeHashMap* _tmp0_;
	GeeHashMap* matches;
	GeeMap* _tmp1_;
	GeeCollection* _tmp2_;
	GeeCollection* _tmp3_;
	GeeCollection* _tmp4_;
	gint _tmp5_ = 0;
	gpointer* _tmp6_ = NULL;
	FolksIndividual** _tmp7_;
	gint _tmp7__length1;
	FolksIndividual** individuals;
	gint individuals_length1;
	gint _individuals_size_;
	FolksPotentialMatch* _tmp8_;
	FolksPotentialMatch* matchObj;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = gee_hash_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, GEE_TYPE_HASH_MAP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL);
	matches = _tmp0_;
	_tmp1_ = self->priv->_individuals;
	_tmp2_ = gee_map_get_values (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = _tmp3_;
	_tmp6_ = gee_collection_to_array (_tmp4_, &_tmp5_);
	_tmp7_ = _tmp6_;
	_tmp7__length1 = _tmp5_;
	_g_object_unref0 (_tmp4_);
	individuals = _tmp7_;
	individuals_length1 = _tmp7__length1;
	_individuals_size_ = individuals_length1;
	_tmp8_ = folks_potential_match_new ();
	matchObj = _tmp8_;
	{
		gint i;
		i = 0;
		{
			gboolean _tmp9_;
			_tmp9_ = TRUE;
			while (TRUE) {
				gboolean _tmp10_;
				gint _tmp12_;
				FolksIndividual** _tmp13_;
				gint _tmp13__length1;
				FolksIndividual** _tmp14_;
				gint _tmp14__length1;
				gint _tmp15_;
				FolksIndividual* _tmp16_;
				FolksIndividual* _tmp17_;
				FolksIndividual* a;
				GeeHashMap* _tmp18_;
				FolksIndividual* _tmp19_;
				gpointer _tmp20_ = NULL;
				GeeHashMap* _matches_a;
				GeeHashMap* matches_a = NULL;
				GeeHashMap* _tmp21_;
				_tmp10_ = _tmp9_;
				if (!_tmp10_) {
					gint _tmp11_;
					_tmp11_ = i;
					i = _tmp11_ + 1;
				}
				_tmp9_ = FALSE;
				_tmp12_ = i;
				_tmp13_ = individuals;
				_tmp13__length1 = individuals_length1;
				if (!(_tmp12_ < _tmp13__length1)) {
					break;
				}
				_tmp14_ = individuals;
				_tmp14__length1 = individuals_length1;
				_tmp15_ = i;
				_tmp16_ = _tmp14_[_tmp15_];
				_tmp17_ = _g_object_ref0 (_tmp16_);
				a = _tmp17_;
				_tmp18_ = matches;
				_tmp19_ = a;
				_tmp20_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp18_, _tmp19_);
				_matches_a = (GeeHashMap*) _tmp20_;
				_tmp21_ = _matches_a;
				if (_tmp21_ == NULL) {
					GeeHashMap* _tmp22_;
					GeeHashMap* _tmp23_;
					FolksIndividual* _tmp24_;
					GeeHashMap* _tmp25_;
					_tmp22_ = gee_hash_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_MATCH_RESULT, NULL, NULL, NULL, NULL, NULL);
					_g_object_unref0 (matches_a);
					matches_a = _tmp22_;
					_tmp23_ = matches;
					_tmp24_ = a;
					_tmp25_ = matches_a;
					gee_abstract_map_set ((GeeAbstractMap*) _tmp23_, _tmp24_, _tmp25_);
				} else {
					GeeHashMap* _tmp26_;
					GeeHashMap* _tmp27_;
					_tmp26_ = _matches_a;
					_tmp27_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, GEE_TYPE_HASH_MAP, GeeHashMap));
					_g_object_unref0 (matches_a);
					matches_a = _tmp27_;
				}
				{
					gint _tmp28_;
					gint f;
					_tmp28_ = i;
					f = _tmp28_ + 1;
					{
						gboolean _tmp29_;
						_tmp29_ = TRUE;
						while (TRUE) {
							gboolean _tmp30_;
							gint _tmp32_;
							FolksIndividual** _tmp33_;
							gint _tmp33__length1;
							FolksIndividual** _tmp34_;
							gint _tmp34__length1;
							gint _tmp35_;
							FolksIndividual* _tmp36_;
							FolksIndividual* _tmp37_;
							FolksIndividual* b;
							GeeHashMap* _tmp38_;
							FolksIndividual* _tmp39_;
							gpointer _tmp40_ = NULL;
							GeeHashMap* _matches_b;
							GeeHashMap* matches_b = NULL;
							GeeHashMap* _tmp41_;
							FolksPotentialMatch* _tmp48_;
							FolksIndividual* _tmp49_;
							FolksIndividual* _tmp50_;
							FolksMatchResult _tmp51_ = 0;
							FolksMatchResult _result_;
							FolksMatchResult _tmp52_;
							FolksMatchResult _tmp53_;
							_tmp30_ = _tmp29_;
							if (!_tmp30_) {
								gint _tmp31_;
								_tmp31_ = f;
								f = _tmp31_ + 1;
							}
							_tmp29_ = FALSE;
							_tmp32_ = f;
							_tmp33_ = individuals;
							_tmp33__length1 = individuals_length1;
							if (!(_tmp32_ < _tmp33__length1)) {
								break;
							}
							_tmp34_ = individuals;
							_tmp34__length1 = individuals_length1;
							_tmp35_ = f;
							_tmp36_ = _tmp34_[_tmp35_];
							_tmp37_ = _g_object_ref0 (_tmp36_);
							b = _tmp37_;
							_tmp38_ = matches;
							_tmp39_ = b;
							_tmp40_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp38_, _tmp39_);
							_matches_b = (GeeHashMap*) _tmp40_;
							_tmp41_ = _matches_b;
							if (_tmp41_ == NULL) {
								GeeHashMap* _tmp42_;
								GeeHashMap* _tmp43_;
								FolksIndividual* _tmp44_;
								GeeHashMap* _tmp45_;
								_tmp42_ = gee_hash_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_MATCH_RESULT, NULL, NULL, NULL, NULL, NULL);
								_g_object_unref0 (matches_b);
								matches_b = _tmp42_;
								_tmp43_ = matches;
								_tmp44_ = b;
								_tmp45_ = matches_b;
								gee_abstract_map_set ((GeeAbstractMap*) _tmp43_, _tmp44_, _tmp45_);
							} else {
								GeeHashMap* _tmp46_;
								GeeHashMap* _tmp47_;
								_tmp46_ = _matches_b;
								_tmp47_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp46_, GEE_TYPE_HASH_MAP, GeeHashMap));
								_g_object_unref0 (matches_b);
								matches_b = _tmp47_;
							}
							_tmp48_ = matchObj;
							_tmp49_ = a;
							_tmp50_ = b;
							_tmp51_ = folks_potential_match_potential_match (_tmp48_, _tmp49_, _tmp50_);
							_result_ = _tmp51_;
							_tmp52_ = _result_;
							_tmp53_ = min_threshold;
							if (_tmp52_ >= _tmp53_) {
								GeeHashMap* _tmp54_;
								FolksIndividual* _tmp55_;
								FolksMatchResult _tmp56_;
								GeeHashMap* _tmp57_;
								FolksIndividual* _tmp58_;
								FolksMatchResult _tmp59_;
								_tmp54_ = matches_a;
								_tmp55_ = b;
								_tmp56_ = _result_;
								gee_abstract_map_set ((GeeAbstractMap*) _tmp54_, _tmp55_, (gpointer) ((gintptr) _tmp56_));
								_tmp57_ = matches_b;
								_tmp58_ = a;
								_tmp59_ = _result_;
								gee_abstract_map_set ((GeeAbstractMap*) _tmp57_, _tmp58_, (gpointer) ((gintptr) _tmp59_));
							}
							_g_object_unref0 (matches_b);
							_g_object_unref0 (_matches_b);
							_g_object_unref0 (b);
						}
					}
				}
				_g_object_unref0 (matches_a);
				_g_object_unref0 (_matches_a);
				_g_object_unref0 (a);
			}
		}
	}
	result = (GeeMap*) matches;
	_g_object_unref0 (matchObj);
	individuals = (_vala_array_free (individuals, individuals_length1, (GDestroyNotify) g_object_unref), NULL);
	return result;
}


static void _folks_individual_aggregator_add_backend_data_free (gpointer _data) {
	FolksIndividualAggregatorAddBackendData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->backend);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorAddBackendData, _data_);
}


static void _folks_individual_aggregator_add_backend (FolksIndividualAggregator* self, FolksBackend* backend, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorAddBackendData* _data_;
	FolksIndividualAggregator* _tmp0_;
	FolksBackend* _tmp1_;
	FolksBackend* _tmp2_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorAddBackendData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, _folks_individual_aggregator_add_backend);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, _folks_individual_aggregator_add_backend_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = backend;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->backend);
	_data_->backend = _tmp2_;
	_folks_individual_aggregator_add_backend_co (_data_);
}


static void _folks_individual_aggregator_add_backend_finish (FolksIndividualAggregator* self, GAsyncResult* _res_) {
	FolksIndividualAggregatorAddBackendData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void __folks_individual_aggregator_backend_persona_store_added_cb_folks_backend_persona_store_added (FolksBackend* _sender, FolksPersonaStore* store, gpointer self) {
	_folks_individual_aggregator_backend_persona_store_added_cb (self, _sender, store);
}


static void __folks_individual_aggregator_backend_persona_store_removed_cb_folks_backend_persona_store_removed (FolksBackend* _sender, FolksPersonaStore* store, gpointer self) {
	_folks_individual_aggregator_backend_persona_store_removed_cb (self, _sender, store);
}


static void __folks_individual_aggregator_backend_is_quiescent_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
	_folks_individual_aggregator_backend_is_quiescent_changed_cb (self, _sender, pspec);
}


static gboolean _folks_individual_aggregator_add_backend_co (FolksIndividualAggregatorAddBackendData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = _data_->self->priv->_backends;
	_data_->_tmp1_ = _data_->backend;
	_data_->_tmp2_ = FALSE;
	_data_->_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data_->_tmp0_, _data_->_tmp1_);
	if (!_data_->_tmp2_) {
		_data_->_tmp3_ = _data_->self->priv->_backends;
		_data_->_tmp4_ = _data_->backend;
		gee_abstract_collection_add ((GeeAbstractCollection*) _data_->_tmp3_, _data_->_tmp4_);
		_data_->_tmp5_ = _data_->backend;
		g_signal_connect_object (_data_->_tmp5_, "persona-store-added", (GCallback) __folks_individual_aggregator_backend_persona_store_added_cb_folks_backend_persona_store_added, _data_->self, 0);
		_data_->_tmp6_ = _data_->backend;
		g_signal_connect_object (_data_->_tmp6_, "persona-store-removed", (GCallback) __folks_individual_aggregator_backend_persona_store_removed_cb_folks_backend_persona_store_removed, _data_->self, 0);
		_data_->_tmp7_ = _data_->backend;
		g_signal_connect_object ((GObject*) _data_->_tmp7_, "notify::is-quiescent", (GCallback) __folks_individual_aggregator_backend_is_quiescent_changed_cb_g_object_notify, _data_->self, 0);
		_data_->_tmp8_ = _data_->backend;
		_data_->_tmp9_ = folks_backend_get_persona_stores (_data_->_tmp8_);
		_data_->_tmp10_ = _data_->_tmp9_;
		_data_->_tmp11_ = gee_map_get_values (_data_->_tmp10_);
		_data_->_tmp12_ = _data_->_tmp11_;
		_data_->_tmp13_ = _data_->_tmp12_;
		_data_->_tmp14_ = 0;
		_data_->_tmp15_ = NULL;
		_data_->_tmp15_ = gee_collection_to_array (_data_->_tmp13_, &_data_->_tmp14_);
		_data_->_tmp16_ = _data_->_tmp15_;
		_data_->_tmp16__length1 = _data_->_tmp14_;
		_g_object_unref0 (_data_->_tmp13_);
		_data_->stores = _data_->_tmp16_;
		_data_->stores_length1 = _data_->_tmp16__length1;
		_data_->_stores_size_ = _data_->stores_length1;
		_data_->_tmp17_ = _data_->stores;
		_data_->_tmp17__length1 = _data_->stores_length1;
		{
			_data_->persona_store_collection_length1 = 0;
			_data_->_persona_store_collection_size_ = 0;
			_data_->persona_store_collection = _data_->_tmp17_;
			_data_->persona_store_collection_length1 = _data_->_tmp17__length1;
			for (_data_->persona_store_it = 0; _data_->persona_store_it < _data_->_tmp17__length1; _data_->persona_store_it = _data_->persona_store_it + 1) {
				_data_->_tmp18_ = _g_object_ref0 (_data_->persona_store_collection[_data_->persona_store_it]);
				_data_->persona_store = _data_->_tmp18_;
				{
					_data_->_tmp19_ = _data_->backend;
					_data_->_tmp20_ = _data_->persona_store;
					_folks_individual_aggregator_backend_persona_store_added_cb (_data_->self, _data_->_tmp19_, _data_->_tmp20_);
					_g_object_unref0 (_data_->persona_store);
				}
			}
		}
		_data_->stores = (_vala_array_free (_data_->stores, _data_->stores_length1, (GDestroyNotify) g_object_unref), NULL);
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static gboolean __folks_individual_aggregator_quiescent_timeout_cb_gsource_func (gpointer self) {
	gboolean result;
	result = _folks_individual_aggregator_quiescent_timeout_cb (self);
	return result;
}


static void _folks_individual_aggregator_backend_available_cb (FolksIndividualAggregator* self, FolksBackendStore* backend_store, FolksBackend* backend) {
	FolksBackend* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	FolksBackend* _tmp6_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (backend_store != NULL);
	g_return_if_fail (backend != NULL);
	_tmp0_ = backend;
	_tmp1_ = folks_backend_get_is_quiescent (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == FALSE) {
		guint _tmp3_;
		guint _tmp4_;
		_tmp3_ = self->priv->_non_quiescent_backend_count;
		self->priv->_non_quiescent_backend_count = _tmp3_ + 1;
		_tmp4_ = self->priv->_quiescent_timeout_id;
		if (_tmp4_ == ((guint) 0)) {
			guint _tmp5_ = 0U;
			_tmp5_ = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, FOLKS_INDIVIDUAL_AGGREGATOR__QUIESCENT_TIMEOUT, __folks_individual_aggregator_quiescent_timeout_cb_gsource_func, g_object_ref (self), g_object_unref);
			self->priv->_quiescent_timeout_id = _tmp5_;
		}
	}
	_tmp6_ = backend;
	_folks_individual_aggregator_add_backend (self, _tmp6_, NULL, NULL);
}


static void _folks_individual_aggregator_set_primary_store (FolksIndividualAggregator* self, FolksPersonaStore* store) {
	FolksPersonaStore* _tmp0_;
	FolksPersonaStore* _tmp1_;
	FolksPersonaStore* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (store != NULL);
	g_debug ("individual-aggregator.vala:757: _set_primary_store()");
	_tmp0_ = self->priv->_primary_store;
	_tmp1_ = store;
	if (_tmp0_ == _tmp1_) {
		return;
	}
	_tmp2_ = store;
	_tmp3_ = folks_persona_store_get_type_id (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = self->priv->_configured_primary_store_type_id;
	if (g_strcmp0 (_tmp4_, _tmp5_) == 0) {
		gboolean _tmp6_ = FALSE;
		gboolean _tmp7_ = FALSE;
		FolksPersonaStore* _tmp8_;
		const gchar* _tmp9_;
		const gchar* _tmp10_;
		gboolean _tmp12_;
		gboolean _tmp17_;
		_tmp8_ = store;
		_tmp9_ = folks_persona_store_get_type_id (_tmp8_);
		_tmp10_ = _tmp9_;
		if (g_strcmp0 (_tmp10_, "eds") != 0) {
			const gchar* _tmp11_;
			_tmp11_ = self->priv->_configured_primary_store_id;
			_tmp7_ = g_strcmp0 (_tmp11_, "") == 0;
		} else {
			_tmp7_ = FALSE;
		}
		_tmp12_ = _tmp7_;
		if (_tmp12_) {
			_tmp6_ = TRUE;
		} else {
			const gchar* _tmp13_;
			FolksPersonaStore* _tmp14_;
			const gchar* _tmp15_;
			const gchar* _tmp16_;
			_tmp13_ = self->priv->_configured_primary_store_id;
			_tmp14_ = store;
			_tmp15_ = folks_persona_store_get_id (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp6_ = g_strcmp0 (_tmp13_, _tmp16_) == 0;
		}
		_tmp17_ = _tmp6_;
		if (_tmp17_) {
			FolksPersonaStore* _tmp18_;
			FolksPersonaStore* _tmp19_;
			const gchar* _tmp20_;
			const gchar* _tmp21_;
			FolksPersonaStore* _tmp22_;
			const gchar* _tmp23_;
			const gchar* _tmp24_;
			FolksPersonaStore* _tmp25_;
			FolksPersonaStore* _tmp26_;
			FolksPersonaStore* previous_store;
			FolksPersonaStore* _tmp27_;
			FolksPersonaStore* _tmp28_;
			FolksPersonaStore* _tmp29_;
			FolksPersonaStore* _tmp32_;
			FolksPersonaStore* _tmp33_;
			FolksPersonaStore* _tmp35_;
			_tmp18_ = store;
			_tmp19_ = store;
			_tmp20_ = folks_persona_store_get_type_id (_tmp19_);
			_tmp21_ = _tmp20_;
			_tmp22_ = store;
			_tmp23_ = folks_persona_store_get_id (_tmp22_);
			_tmp24_ = _tmp23_;
			g_debug ("individual-aggregator.vala:774: Setting primary store to %p (type ID: " \
"%s, ID: %s)", _tmp18_, _tmp21_, _tmp24_);
			_tmp25_ = self->priv->_primary_store;
			_tmp26_ = _g_object_ref0 (_tmp25_);
			previous_store = _tmp26_;
			_tmp27_ = store;
			self->priv->_primary_store = _tmp27_;
			_tmp28_ = store;
			g_object_freeze_notify ((GObject*) _tmp28_);
			_tmp29_ = previous_store;
			if (_tmp29_ != NULL) {
				FolksPersonaStore* _tmp30_;
				FolksPersonaStore* _tmp31_;
				_tmp30_ = previous_store;
				g_object_freeze_notify ((GObject*) G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore));
				_tmp31_ = previous_store;
				folks_persona_store_set_is_primary_store (G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore), FALSE);
			}
			_tmp32_ = store;
			folks_persona_store_set_is_primary_store (_tmp32_, TRUE);
			_tmp33_ = previous_store;
			if (_tmp33_ != NULL) {
				FolksPersonaStore* _tmp34_;
				_tmp34_ = previous_store;
				g_object_thaw_notify ((GObject*) G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore));
			}
			_tmp35_ = store;
			g_object_thaw_notify ((GObject*) _tmp35_);
			g_object_notify ((GObject*) self, "primary-store");
			_g_object_unref0 (previous_store);
		}
	}
}


static Block4Data* block4_data_ref (Block4Data* _data4_) {
	g_atomic_int_inc (&_data4_->_ref_count_);
	return _data4_;
}


static void block4_data_unref (void * _userdata_) {
	Block4Data* _data4_;
	_data4_ = (Block4Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
		FolksIndividualAggregator * self;
		self = _data4_->self;
		_g_free0 (_data4_->store_id);
		_g_object_unref0 (_data4_->store);
		_g_object_unref0 (self);
		g_slice_free (Block4Data, _data4_);
	}
}


static void __folks_individual_aggregator_personas_changed_cb_folks_persona_store_personas_changed (FolksPersonaStore* _sender, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason, gpointer self) {
	_folks_individual_aggregator_personas_changed_cb (self, _sender, added, removed, message, actor, reason);
}


static void __folks_individual_aggregator_is_primary_store_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
	_folks_individual_aggregator_is_primary_store_changed_cb (self, _sender, pspec);
}


static void __folks_individual_aggregator_persona_store_is_quiescent_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
	_folks_individual_aggregator_persona_store_is_quiescent_changed_cb (self, _sender, pspec);
}


static void __folks_individual_aggregator_persona_store_is_user_set_default_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
	_folks_individual_aggregator_persona_store_is_user_set_default_changed_cb (self, _sender, pspec);
}


static void __lambda64_ (Block4Data* _data4_, GObject* obj, GAsyncResult* _result_) {
	FolksIndividualAggregator * self;
	GError * _inner_error_ = NULL;
	self = _data4_->self;
	g_return_if_fail (_result_ != NULL);
	{
		FolksPersonaStore* _tmp0_;
		GAsyncResult* _tmp1_;
		_tmp0_ = _data4_->store;
		_tmp1_ = _result_;
		folks_persona_store_prepare_finish (_tmp0_, _tmp1_, &_inner_error_);
		if (_inner_error_ != NULL) {
			goto __catch17_g_error;
		}
	}
	goto __finally17;
	__catch17_g_error:
	{
		GError* e = NULL;
		const gchar* _tmp2_ = NULL;
		const gchar* _tmp3_;
		GError* _tmp4_;
		const gchar* _tmp5_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp2_ = _ ("Error preparing persona store '%s': %s");
		_tmp3_ = _data4_->store_id;
		_tmp4_ = e;
		_tmp5_ = _tmp4_->message;
		g_warning (_tmp2_, _tmp3_, _tmp5_);
		_g_error_free0 (e);
	}
	__finally17:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return;
	}
}


static void ___lambda64__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	__lambda64_ (self, source_object, res);
	block4_data_unref (self);
}


static void _folks_individual_aggregator_backend_persona_store_added_cb (FolksIndividualAggregator* self, FolksBackend* backend, FolksPersonaStore* store) {
	Block4Data* _data4_;
	FolksPersonaStore* _tmp0_;
	FolksPersonaStore* _tmp1_;
	FolksBackend* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	FolksPersonaStore* _tmp5_;
	const gchar* _tmp6_;
	const gchar* _tmp7_;
	FolksPersonaStore* _tmp8_;
	FolksPersonaStore* _tmp9_;
	const gchar* _tmp10_;
	const gchar* _tmp11_;
	FolksPersonaStore* _tmp12_;
	const gchar* _tmp13_;
	const gchar* _tmp14_;
	gchar* _tmp15_ = NULL;
	FolksPersonaStore* _tmp16_;
	FolksPersonaStore* _tmp17_;
	GeeHashMap* _tmp18_;
	const gchar* _tmp19_;
	FolksPersonaStore* _tmp20_;
	FolksPersonaStore* _tmp21_;
	FolksPersonaStore* _tmp22_;
	FolksPersonaStore* _tmp23_;
	FolksPersonaStore* _tmp24_;
	FolksPersonaStore* _tmp25_;
	gboolean _tmp26_;
	gboolean _tmp27_;
	FolksPersonaStore* _tmp31_;
	GeeMap* _tmp32_;
	GeeMap* _tmp33_;
	gint _tmp34_;
	gint _tmp35_;
	FolksPersonaStore* _tmp55_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (backend != NULL);
	g_return_if_fail (store != NULL);
	_data4_ = g_slice_new0 (Block4Data);
	_data4_->_ref_count_ = 1;
	_data4_->self = g_object_ref (self);
	_tmp0_ = store;
	_tmp1_ = _g_object_ref0 (_tmp0_);
	_g_object_unref0 (_data4_->store);
	_data4_->store = _tmp1_;
	_tmp2_ = backend;
	_tmp3_ = folks_backend_get_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _data4_->store;
	_tmp6_ = folks_persona_store_get_id (_tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = _data4_->store;
	g_debug ("individual-aggregator.vala:799: _backend_persona_store_added_cb(): bac" \
"kend: %s, store: %s (%p)", _tmp4_, _tmp7_, _tmp8_);
	_tmp9_ = _data4_->store;
	_tmp10_ = folks_persona_store_get_type_id (_tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = _data4_->store;
	_tmp13_ = folks_persona_store_get_id (_tmp12_);
	_tmp14_ = _tmp13_;
	_tmp15_ = _folks_individual_aggregator_get_store_full_id (self, _tmp11_, _tmp14_);
	_data4_->store_id = _tmp15_;
	_tmp16_ = _data4_->store;
	_folks_individual_aggregator_maybe_configure_as_primary (self, _tmp16_);
	_tmp17_ = _data4_->store;
	_folks_individual_aggregator_set_primary_store (self, _tmp17_);
	_tmp18_ = self->priv->_stores;
	_tmp19_ = _data4_->store_id;
	_tmp20_ = _data4_->store;
	gee_abstract_map_set ((GeeAbstractMap*) _tmp18_, _tmp19_, _tmp20_);
	_tmp21_ = _data4_->store;
	g_signal_connect_object (_tmp21_, "personas-changed", (GCallback) __folks_individual_aggregator_personas_changed_cb_folks_persona_store_personas_changed, self, 0);
	_tmp22_ = _data4_->store;
	g_signal_connect_object ((GObject*) _tmp22_, "notify::is-primary-store", (GCallback) __folks_individual_aggregator_is_primary_store_changed_cb_g_object_notify, self, 0);
	_tmp23_ = _data4_->store;
	g_signal_connect_object ((GObject*) _tmp23_, "notify::is-quiescent", (GCallback) __folks_individual_aggregator_persona_store_is_quiescent_changed_cb_g_object_notify, self, 0);
	_tmp24_ = _data4_->store;
	g_signal_connect_object ((GObject*) _tmp24_, "notify::is-user-set-default", (GCallback) __folks_individual_aggregator_persona_store_is_user_set_default_changed_cb_g_object_notify, self, 0);
	_tmp25_ = _data4_->store;
	_tmp26_ = folks_persona_store_get_is_quiescent (_tmp25_);
	_tmp27_ = _tmp26_;
	if (_tmp27_ == FALSE) {
		guint _tmp28_;
		guint _tmp29_;
		_tmp28_ = self->priv->_non_quiescent_persona_store_count;
		self->priv->_non_quiescent_persona_store_count = _tmp28_ + 1;
		_tmp29_ = self->priv->_quiescent_timeout_id;
		if (_tmp29_ == ((guint) 0)) {
			guint _tmp30_ = 0U;
			_tmp30_ = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, FOLKS_INDIVIDUAL_AGGREGATOR__QUIESCENT_TIMEOUT, __folks_individual_aggregator_quiescent_timeout_cb_gsource_func, g_object_ref (self), g_object_unref);
			self->priv->_quiescent_timeout_id = _tmp30_;
		}
	}
	_tmp31_ = _data4_->store;
	_tmp32_ = folks_persona_store_get_personas (_tmp31_);
	_tmp33_ = _tmp32_;
	_tmp34_ = gee_map_get_size (_tmp33_);
	_tmp35_ = _tmp34_;
	if (_tmp35_ > 0) {
		GeeHashSet* _tmp36_;
		GeeHashSet* persona_set;
		FolksPersonaStore* _tmp51_;
		GeeHashSet* _tmp52_;
		GeeHashSet* _tmp53_;
		GeeHashSet* _tmp54_;
		_tmp36_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
		persona_set = _tmp36_;
		{
			FolksPersonaStore* _tmp37_;
			GeeMap* _tmp38_;
			GeeMap* _tmp39_;
			GeeCollection* _tmp40_;
			GeeCollection* _tmp41_;
			GeeCollection* _tmp42_;
			GeeIterator* _tmp43_ = NULL;
			GeeIterator* _tmp44_;
			GeeIterator* _p_it;
			_tmp37_ = _data4_->store;
			_tmp38_ = folks_persona_store_get_personas (_tmp37_);
			_tmp39_ = _tmp38_;
			_tmp40_ = gee_map_get_values (_tmp39_);
			_tmp41_ = _tmp40_;
			_tmp42_ = _tmp41_;
			_tmp43_ = gee_iterable_iterator ((GeeIterable*) _tmp42_);
			_tmp44_ = _tmp43_;
			_g_object_unref0 (_tmp42_);
			_p_it = _tmp44_;
			while (TRUE) {
				GeeIterator* _tmp45_;
				gboolean _tmp46_ = FALSE;
				GeeIterator* _tmp47_;
				gpointer _tmp48_ = NULL;
				FolksPersona* p;
				GeeHashSet* _tmp49_;
				FolksPersona* _tmp50_;
				_tmp45_ = _p_it;
				_tmp46_ = gee_iterator_next (_tmp45_);
				if (!_tmp46_) {
					break;
				}
				_tmp47_ = _p_it;
				_tmp48_ = gee_iterator_get (_tmp47_);
				p = (FolksPersona*) _tmp48_;
				_tmp49_ = persona_set;
				_tmp50_ = p;
				gee_abstract_collection_add ((GeeAbstractCollection*) _tmp49_, _tmp50_);
				_g_object_unref0 (p);
			}
			_g_object_unref0 (_p_it);
		}
		_tmp51_ = _data4_->store;
		_tmp52_ = persona_set;
		_tmp53_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
		_tmp54_ = _tmp53_;
		_folks_individual_aggregator_personas_changed_cb (self, _tmp51_, (GeeSet*) _tmp52_, (GeeSet*) _tmp54_, NULL, NULL, FOLKS_GROUP_DETAILS_CHANGE_REASON_NONE);
		_g_object_unref0 (_tmp54_);
		_g_object_unref0 (persona_set);
	}
	_tmp55_ = _data4_->store;
	folks_persona_store_prepare (_tmp55_, ___lambda64__gasync_ready_callback, block4_data_ref (_data4_));
	block4_data_unref (_data4_);
	_data4_ = NULL;
}


static void _folks_individual_aggregator_backend_persona_store_removed_cb (FolksIndividualAggregator* self, FolksBackend* backend, FolksPersonaStore* store) {
	FolksPersonaStore* _tmp0_;
	guint _tmp1_ = 0U;
	FolksPersonaStore* _tmp2_;
	guint _tmp3_ = 0U;
	GQuark _tmp4_ = 0U;
	FolksPersonaStore* _tmp5_;
	guint _tmp6_ = 0U;
	GQuark _tmp7_ = 0U;
	FolksPersonaStore* _tmp8_;
	guint _tmp9_ = 0U;
	GQuark _tmp10_ = 0U;
	gboolean _tmp11_ = FALSE;
	gboolean _tmp12_;
	gboolean _tmp16_;
	FolksPersonaStore* _tmp18_;
	FolksPersonaStore* _tmp19_;
	GeeHashMap* _tmp27_;
	FolksPersonaStore* _tmp28_;
	const gchar* _tmp29_;
	const gchar* _tmp30_;
	FolksPersonaStore* _tmp31_;
	const gchar* _tmp32_;
	const gchar* _tmp33_;
	gchar* _tmp34_ = NULL;
	gchar* _tmp35_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (backend != NULL);
	g_return_if_fail (store != NULL);
	_tmp0_ = store;
	g_signal_parse_name ("personas-changed", FOLKS_TYPE_PERSONA_STORE, &_tmp1_, NULL, FALSE);
	g_signal_handlers_disconnect_matched (_tmp0_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) __folks_individual_aggregator_personas_changed_cb_folks_persona_store_personas_changed, self);
	_tmp2_ = store;
	g_signal_parse_name ("notify::is-quiescent", G_TYPE_OBJECT, &_tmp3_, &_tmp4_, TRUE);
	g_signal_handlers_disconnect_matched ((GObject*) _tmp2_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, _tmp4_, NULL, (GCallback) __folks_individual_aggregator_persona_store_is_quiescent_changed_cb_g_object_notify, self);
	_tmp5_ = store;
	g_signal_parse_name ("notify::is-primary-store", G_TYPE_OBJECT, &_tmp6_, &_tmp7_, TRUE);
	g_signal_handlers_disconnect_matched ((GObject*) _tmp5_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp6_, _tmp7_, NULL, (GCallback) __folks_individual_aggregator_is_primary_store_changed_cb_g_object_notify, self);
	_tmp8_ = store;
	g_signal_parse_name ("notify::is-user-set-default", G_TYPE_OBJECT, &_tmp9_, &_tmp10_, TRUE);
	g_signal_handlers_disconnect_matched ((GObject*) _tmp8_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp9_, _tmp10_, NULL, (GCallback) __folks_individual_aggregator_persona_store_is_user_set_default_changed_cb_g_object_notify, self);
	_tmp12_ = self->priv->_is_quiescent;
	if (_tmp12_ == FALSE) {
		FolksPersonaStore* _tmp13_;
		gboolean _tmp14_;
		gboolean _tmp15_;
		_tmp13_ = store;
		_tmp14_ = folks_persona_store_get_is_quiescent (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp11_ = _tmp15_ == FALSE;
	} else {
		_tmp11_ = FALSE;
	}
	_tmp16_ = _tmp11_;
	if (_tmp16_) {
		guint _tmp17_;
		_tmp17_ = self->priv->_non_quiescent_persona_store_count;
		self->priv->_non_quiescent_persona_store_count = _tmp17_ - 1;
		_folks_individual_aggregator_notify_if_is_quiescent (self);
	}
	_tmp18_ = self->priv->_primary_store;
	_tmp19_ = store;
	if (_tmp18_ == _tmp19_) {
		FolksPersonaStore* _tmp20_;
		FolksPersonaStore* _tmp21_;
		const gchar* _tmp22_;
		const gchar* _tmp23_;
		FolksPersonaStore* _tmp24_;
		const gchar* _tmp25_;
		const gchar* _tmp26_;
		_tmp20_ = store;
		_tmp21_ = store;
		_tmp22_ = folks_persona_store_get_type_id (_tmp21_);
		_tmp23_ = _tmp22_;
		_tmp24_ = store;
		_tmp25_ = folks_persona_store_get_id (_tmp24_);
		_tmp26_ = _tmp25_;
		g_debug ("Unsetting primary store as store %p (type ID: %s, ID: %s) " "has been removed", _tmp20_, _tmp23_, _tmp26_);
		self->priv->_primary_store = NULL;
		g_object_notify ((GObject*) self, "primary-store");
	}
	_tmp27_ = self->priv->_stores;
	_tmp28_ = store;
	_tmp29_ = folks_persona_store_get_type_id (_tmp28_);
	_tmp30_ = _tmp29_;
	_tmp31_ = store;
	_tmp32_ = folks_persona_store_get_id (_tmp31_);
	_tmp33_ = _tmp32_;
	_tmp34_ = _folks_individual_aggregator_get_store_full_id (self, _tmp30_, _tmp33_);
	_tmp35_ = _tmp34_;
	gee_abstract_map_unset ((GeeAbstractMap*) _tmp27_, _tmp35_, NULL);
	_g_free0 (_tmp35_);
}


static gchar* _folks_individual_aggregator_get_store_full_id (FolksIndividualAggregator* self, const gchar* type_id, const gchar* id) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type_id != NULL, NULL);
	g_return_val_if_fail (id != NULL, NULL);
	_tmp0_ = type_id;
	_tmp1_ = g_strconcat (_tmp0_, ":", NULL);
	_tmp2_ = _tmp1_;
	_tmp3_ = id;
	_tmp4_ = g_strconcat (_tmp2_, _tmp3_, NULL);
	_tmp5_ = _tmp4_;
	_g_free0 (_tmp2_);
	result = _tmp5_;
	return result;
}


static void _folks_individual_aggregator_emit_individuals_changed (FolksIndividualAggregator* self, GeeSet* added, GeeSet* removed, GeeMultiMap* changes, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason) {
	GeeSet* _added = NULL;
	GeeSet* _removed = NULL;
	GeeMultiMap* _changes = NULL;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	GeeSet* _tmp3_;
	gboolean _tmp7_;
	gboolean _tmp14_;
	gboolean _tmp21_;
	GeeSet* _tmp22_ = NULL;
	GeeSet* _tmp23_;
	GeeSet* _tmp27_;
	GeeSet* _tmp28_;
	GeeSet* _tmp29_ = NULL;
	GeeSet* _tmp30_;
	GeeSet* _tmp34_;
	GeeSet* _tmp35_;
	GeeMultiMap* _tmp36_;
	FolksDebug* _tmp40_;
	gboolean _tmp41_;
	gboolean _tmp42_;
	GeeSet* _tmp105_;
	GeeSet* _tmp106_;
	GeeSet* _tmp107_;
	GeeSet* _tmp108_;
	GeeSet* _tmp109_;
	GeeSet* _tmp110_;
	GeeSet* _tmp111_;
	GeeSet* _tmp112_;
	const gchar* _tmp113_;
	FolksPersona* _tmp114_;
	FolksGroupDetailsChangeReason _tmp115_;
	GeeMultiMap* _tmp116_;
	g_return_if_fail (self != NULL);
	_tmp3_ = added;
	if (_tmp3_ == NULL) {
		_tmp2_ = TRUE;
	} else {
		GeeSet* _tmp4_;
		gint _tmp5_;
		gint _tmp6_;
		_tmp4_ = added;
		_tmp5_ = gee_collection_get_size ((GeeCollection*) G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, GEE_TYPE_SET, GeeSet));
		_tmp6_ = _tmp5_;
		_tmp2_ = _tmp6_ == 0;
	}
	_tmp7_ = _tmp2_;
	if (_tmp7_) {
		gboolean _tmp8_ = FALSE;
		GeeSet* _tmp9_;
		gboolean _tmp13_;
		_tmp9_ = removed;
		if (_tmp9_ == NULL) {
			_tmp8_ = TRUE;
		} else {
			GeeSet* _tmp10_;
			gint _tmp11_;
			gint _tmp12_;
			_tmp10_ = removed;
			_tmp11_ = gee_collection_get_size ((GeeCollection*) G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, GEE_TYPE_SET, GeeSet));
			_tmp12_ = _tmp11_;
			_tmp8_ = _tmp12_ == 0;
		}
		_tmp13_ = _tmp8_;
		_tmp1_ = _tmp13_;
	} else {
		_tmp1_ = FALSE;
	}
	_tmp14_ = _tmp1_;
	if (_tmp14_) {
		gboolean _tmp15_ = FALSE;
		GeeMultiMap* _tmp16_;
		gboolean _tmp20_;
		_tmp16_ = changes;
		if (_tmp16_ == NULL) {
			_tmp15_ = TRUE;
		} else {
			GeeMultiMap* _tmp17_;
			gint _tmp18_;
			gint _tmp19_;
			_tmp17_ = changes;
			_tmp18_ = gee_multi_map_get_size (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, GEE_TYPE_MULTI_MAP, GeeMultiMap));
			_tmp19_ = _tmp18_;
			_tmp15_ = _tmp19_ == 0;
		}
		_tmp20_ = _tmp15_;
		_tmp0_ = _tmp20_;
	} else {
		_tmp0_ = FALSE;
	}
	_tmp21_ = _tmp0_;
	if (_tmp21_) {
		_g_object_unref0 (_changes);
		_g_object_unref0 (_removed);
		_g_object_unref0 (_added);
		return;
	}
	folks_internal_profiling_point ("emitting " "IndividualAggregator::individuals-changed", NULL);
	_tmp23_ = added;
	if (_tmp23_ != NULL) {
		GeeSet* _tmp24_;
		GeeSet* _tmp25_;
		_tmp24_ = added;
		_tmp25_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, GEE_TYPE_SET, GeeSet));
		_g_object_unref0 (_tmp22_);
		_tmp22_ = _tmp25_;
	} else {
		GeeHashSet* _tmp26_;
		_tmp26_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
		_g_object_unref0 (_tmp22_);
		_tmp22_ = (GeeSet*) _tmp26_;
	}
	_tmp27_ = _tmp22_;
	_tmp28_ = _g_object_ref0 (_tmp27_);
	_g_object_unref0 (_added);
	_added = _tmp28_;
	_tmp30_ = removed;
	if (_tmp30_ != NULL) {
		GeeSet* _tmp31_;
		GeeSet* _tmp32_;
		_tmp31_ = removed;
		_tmp32_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, GEE_TYPE_SET, GeeSet));
		_g_object_unref0 (_tmp29_);
		_tmp29_ = _tmp32_;
	} else {
		GeeHashSet* _tmp33_;
		_tmp33_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
		_g_object_unref0 (_tmp29_);
		_tmp29_ = (GeeSet*) _tmp33_;
	}
	_tmp34_ = _tmp29_;
	_tmp35_ = _g_object_ref0 (_tmp34_);
	_g_object_unref0 (_removed);
	_removed = _tmp35_;
	_tmp36_ = changes;
	if (_tmp36_ != NULL) {
		GeeMultiMap* _tmp37_;
		GeeMultiMap* _tmp38_;
		_tmp37_ = changes;
		_tmp38_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp37_, GEE_TYPE_MULTI_MAP, GeeMultiMap));
		_g_object_unref0 (_changes);
		_changes = _tmp38_;
	} else {
		GeeHashMultiMap* _tmp39_;
		_tmp39_ = gee_hash_multi_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL, NULL);
		_g_object_unref0 (_changes);
		_changes = (GeeMultiMap*) _tmp39_;
	}
	_tmp40_ = self->priv->_debug;
	_tmp41_ = folks_debug_get_debug_output_enabled (_tmp40_);
	_tmp42_ = _tmp41_;
	if (_tmp42_ == TRUE) {
		GeeMultiMap* _tmp43_;
		gint _tmp44_;
		gint _tmp45_;
		_tmp43_ = _changes;
		_tmp44_ = gee_multi_map_get_size (_tmp43_);
		_tmp45_ = _tmp44_;
		g_debug ("individual-aggregator.vala:947: Emitting individuals-changed-detailed " \
"with %u mappings:", (guint) _tmp45_);
		{
			GeeMultiMap* _tmp46_;
			GeeSet* _tmp47_ = NULL;
			GeeSet* _tmp48_;
			GeeIterator* _tmp49_ = NULL;
			GeeIterator* _tmp50_;
			GeeIterator* _removed_ind_it;
			_tmp46_ = _changes;
			_tmp47_ = gee_multi_map_get_keys (_tmp46_);
			_tmp48_ = _tmp47_;
			_tmp49_ = gee_iterable_iterator ((GeeIterable*) _tmp48_);
			_tmp50_ = _tmp49_;
			_g_object_unref0 (_tmp48_);
			_removed_ind_it = _tmp50_;
			while (TRUE) {
				GeeIterator* _tmp51_;
				gboolean _tmp52_ = FALSE;
				GeeIterator* _tmp53_;
				gpointer _tmp54_ = NULL;
				FolksIndividual* removed_ind;
				_tmp51_ = _removed_ind_it;
				_tmp52_ = gee_iterator_next (_tmp51_);
				if (!_tmp52_) {
					break;
				}
				_tmp53_ = _removed_ind_it;
				_tmp54_ = gee_iterator_get (_tmp53_);
				removed_ind = (FolksIndividual*) _tmp54_;
				{
					GeeMultiMap* _tmp55_;
					FolksIndividual* _tmp56_;
					GeeCollection* _tmp57_ = NULL;
					GeeCollection* _tmp58_;
					GeeIterator* _tmp59_ = NULL;
					GeeIterator* _tmp60_;
					GeeIterator* _added_ind_it;
					_tmp55_ = _changes;
					_tmp56_ = removed_ind;
					_tmp57_ = gee_multi_map_get (_tmp55_, _tmp56_);
					_tmp58_ = _tmp57_;
					_tmp59_ = gee_iterable_iterator ((GeeIterable*) _tmp58_);
					_tmp60_ = _tmp59_;
					_g_object_unref0 (_tmp58_);
					_added_ind_it = _tmp60_;
					while (TRUE) {
						GeeIterator* _tmp61_;
						gboolean _tmp62_ = FALSE;
						GeeIterator* _tmp63_;
						gpointer _tmp64_ = NULL;
						FolksIndividual* added_ind;
						const gchar* _tmp65_ = NULL;
						FolksIndividual* _tmp66_;
						const gchar* _tmp70_ = NULL;
						FolksIndividual* _tmp71_;
						const gchar* _tmp75_;
						FolksIndividual* _tmp76_;
						const gchar* _tmp77_;
						FolksIndividual* _tmp78_;
						FolksIndividual* _tmp79_;
						FolksIndividual* _tmp92_;
						_tmp61_ = _added_ind_it;
						_tmp62_ = gee_iterator_next (_tmp61_);
						if (!_tmp62_) {
							break;
						}
						_tmp63_ = _added_ind_it;
						_tmp64_ = gee_iterator_get (_tmp63_);
						added_ind = (FolksIndividual*) _tmp64_;
						_tmp66_ = removed_ind;
						if (_tmp66_ != NULL) {
							FolksIndividual* _tmp67_;
							const gchar* _tmp68_;
							const gchar* _tmp69_;
							_tmp67_ = removed_ind;
							_tmp68_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp67_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
							_tmp69_ = _tmp68_;
							_tmp65_ = _tmp69_;
						} else {
							_tmp65_ = "";
						}
						_tmp71_ = added_ind;
						if (_tmp71_ != NULL) {
							FolksIndividual* _tmp72_;
							const gchar* _tmp73_;
							const gchar* _tmp74_;
							_tmp72_ = added_ind;
							_tmp73_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp72_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
							_tmp74_ = _tmp73_;
							_tmp70_ = _tmp74_;
						} else {
							_tmp70_ = "";
						}
						_tmp75_ = _tmp65_;
						_tmp76_ = removed_ind;
						_tmp77_ = _tmp70_;
						_tmp78_ = added_ind;
						g_debug ("individual-aggregator.vala:954:     %s (%p) → %s (%p)", _tmp75_, _tmp76_, _tmp77_, _tmp78_);
						_tmp79_ = removed_ind;
						if (_tmp79_ != NULL) {
							g_debug ("individual-aggregator.vala:961:       Removed individual's personas:");
							{
								FolksIndividual* _tmp80_;
								GeeSet* _tmp81_;
								GeeSet* _tmp82_;
								GeeIterator* _tmp83_ = NULL;
								GeeIterator* _p_it;
								_tmp80_ = removed_ind;
								_tmp81_ = folks_individual_get_personas (G_TYPE_CHECK_INSTANCE_CAST (_tmp80_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
								_tmp82_ = _tmp81_;
								_tmp83_ = gee_iterable_iterator ((GeeIterable*) _tmp82_);
								_p_it = _tmp83_;
								while (TRUE) {
									GeeIterator* _tmp84_;
									gboolean _tmp85_ = FALSE;
									GeeIterator* _tmp86_;
									gpointer _tmp87_ = NULL;
									FolksPersona* p;
									FolksPersona* _tmp88_;
									const gchar* _tmp89_;
									const gchar* _tmp90_;
									FolksPersona* _tmp91_;
									_tmp84_ = _p_it;
									_tmp85_ = gee_iterator_next (_tmp84_);
									if (!_tmp85_) {
										break;
									}
									_tmp86_ = _p_it;
									_tmp87_ = gee_iterator_get (_tmp86_);
									p = (FolksPersona*) _tmp87_;
									_tmp88_ = p;
									_tmp89_ = folks_persona_get_uid (_tmp88_);
									_tmp90_ = _tmp89_;
									_tmp91_ = p;
									g_debug ("individual-aggregator.vala:965:         %s (%p)", _tmp90_, _tmp91_);
									_g_object_unref0 (p);
								}
								_g_object_unref0 (_p_it);
							}
						}
						_tmp92_ = added_ind;
						if (_tmp92_ != NULL) {
							g_debug ("individual-aggregator.vala:971:       Added individual's personas:");
							{
								FolksIndividual* _tmp93_;
								GeeSet* _tmp94_;
								GeeSet* _tmp95_;
								GeeIterator* _tmp96_ = NULL;
								GeeIterator* _p_it;
								_tmp93_ = added_ind;
								_tmp94_ = folks_individual_get_personas (G_TYPE_CHECK_INSTANCE_CAST (_tmp93_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
								_tmp95_ = _tmp94_;
								_tmp96_ = gee_iterable_iterator ((GeeIterable*) _tmp95_);
								_p_it = _tmp96_;
								while (TRUE) {
									GeeIterator* _tmp97_;
									gboolean _tmp98_ = FALSE;
									GeeIterator* _tmp99_;
									gpointer _tmp100_ = NULL;
									FolksPersona* p;
									FolksPersona* _tmp101_;
									const gchar* _tmp102_;
									const gchar* _tmp103_;
									FolksPersona* _tmp104_;
									_tmp97_ = _p_it;
									_tmp98_ = gee_iterator_next (_tmp97_);
									if (!_tmp98_) {
										break;
									}
									_tmp99_ = _p_it;
									_tmp100_ = gee_iterator_get (_tmp99_);
									p = (FolksPersona*) _tmp100_;
									_tmp101_ = p;
									_tmp102_ = folks_persona_get_uid (_tmp101_);
									_tmp103_ = _tmp102_;
									_tmp104_ = p;
									g_debug ("individual-aggregator.vala:975:         %s (%p)", _tmp103_, _tmp104_);
									_g_object_unref0 (p);
								}
								_g_object_unref0 (_p_it);
							}
						}
						_g_object_unref0 (added_ind);
					}
					_g_object_unref0 (_added_ind_it);
				}
				_g_object_unref0 (removed_ind);
			}
			_g_object_unref0 (_removed_ind_it);
		}
	}
	_tmp105_ = _added;
	_tmp106_ = gee_set_get_read_only_view (_tmp105_);
	_tmp107_ = _tmp106_;
	_tmp108_ = _tmp107_;
	_tmp109_ = _removed;
	_tmp110_ = gee_set_get_read_only_view (_tmp109_);
	_tmp111_ = _tmp110_;
	_tmp112_ = _tmp111_;
	_tmp113_ = message;
	_tmp114_ = actor;
	_tmp115_ = reason;
	g_signal_emit_by_name (self, "individuals-changed", _tmp108_, _tmp112_, _tmp113_, _tmp114_, _tmp115_);
	_g_object_unref0 (_tmp112_);
	_g_object_unref0 (_tmp108_);
	_tmp116_ = _changes;
	g_signal_emit_by_name (self, "individuals-changed-detailed", _tmp116_);
	_g_object_unref0 (_tmp29_);
	_g_object_unref0 (_tmp22_);
	_g_object_unref0 (_changes);
	_g_object_unref0 (_removed);
	_g_object_unref0 (_added);
}


static void __folks_individual_aggregator_individual_removed_cb_folks_individual_removed (FolksIndividual* _sender, FolksIndividual* replacement_individual, gpointer self) {
	_folks_individual_aggregator_individual_removed_cb (self, _sender, replacement_individual);
}


static void _folks_individual_aggregator_connect_to_individual (FolksIndividualAggregator* self, FolksIndividual* individual) {
	FolksIndividual* _tmp0_;
	GeeMap* _tmp1_;
	FolksIndividual* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	FolksIndividual* _tmp5_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (individual != NULL);
	_tmp0_ = individual;
	g_signal_connect_object (_tmp0_, "removed", (GCallback) __folks_individual_aggregator_individual_removed_cb_folks_individual_removed, self, 0);
	_tmp1_ = self->priv->_individuals;
	_tmp2_ = individual;
	_tmp3_ = folks_individual_get_id (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = individual;
	gee_map_set (_tmp1_, _tmp4_, _tmp5_);
}


static void _folks_individual_aggregator_disconnect_from_individual (FolksIndividualAggregator* self, FolksIndividual* individual) {
	GeeMap* _tmp0_;
	FolksIndividual* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	FolksIndividual* _tmp4_;
	guint _tmp5_ = 0U;
	g_return_if_fail (self != NULL);
	g_return_if_fail (individual != NULL);
	_tmp0_ = self->priv->_individuals;
	_tmp1_ = individual;
	_tmp2_ = folks_individual_get_id (_tmp1_);
	_tmp3_ = _tmp2_;
	gee_map_unset (_tmp0_, _tmp3_, NULL);
	_tmp4_ = individual;
	g_signal_parse_name ("removed", FOLKS_TYPE_INDIVIDUAL, &_tmp5_, NULL, FALSE);
	g_signal_handlers_disconnect_matched (_tmp4_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp5_, 0, NULL, (GCallback) __folks_individual_aggregator_individual_removed_cb_folks_individual_removed, self);
}


static Block5Data* block5_data_ref (Block5Data* _data5_) {
	g_atomic_int_inc (&_data5_->_ref_count_);
	return _data5_;
}


static void block5_data_unref (void * _userdata_) {
	Block5Data* _data5_;
	_data5_ = (Block5Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
		FolksIndividualAggregator * self;
		self = _data5_->self;
		_g_object_unref0 (_data5_->candidate_inds);
		_g_object_unref0 (_data5_->persona);
		_g_object_unref0 (self);
		g_slice_free (Block5Data, _data5_);
	}
}


static Block6Data* block6_data_ref (Block6Data* _data6_) {
	g_atomic_int_inc (&_data6_->_ref_count_);
	return _data6_;
}


static void block6_data_unref (void * _userdata_) {
	Block6Data* _data6_;
	_data6_ = (Block6Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data6_->_ref_count_)) {
		FolksIndividualAggregator * self;
		self = _data6_->_data5_->self;
		block5_data_unref (_data6_->_data5_);
		_data6_->_data5_ = NULL;
		g_slice_free (Block6Data, _data6_);
	}
}


static void _______lambda62_ (Block6Data* _data6_, const gchar* l) {
	Block5Data* _data5_;
	FolksIndividualAggregator * self;
	const gchar* _tmp0_;
	const gchar* prop_linking_value;
	GeeHashMultiMap* _tmp1_;
	const gchar* _tmp2_;
	GeeCollection* _tmp3_ = NULL;
	GeeCollection* candidate_ind_set;
	GeeCollection* _tmp4_;
	_data5_ = _data6_->_data5_;
	self = _data5_->self;
	g_return_if_fail (l != NULL);
	_tmp0_ = l;
	prop_linking_value = _tmp0_;
	_tmp1_ = self->priv->_link_map;
	_tmp2_ = prop_linking_value;
	_tmp3_ = gee_multi_map_get ((GeeMultiMap*) _tmp1_, _tmp2_);
	candidate_ind_set = _tmp3_;
	_tmp4_ = candidate_ind_set;
	if (_tmp4_ != NULL) {
		{
			GeeCollection* _tmp5_;
			GeeIterator* _tmp6_ = NULL;
			GeeIterator* _candidate_ind_it;
			_tmp5_ = candidate_ind_set;
			_tmp6_ = gee_iterable_iterator ((GeeIterable*) _tmp5_);
			_candidate_ind_it = _tmp6_;
			while (TRUE) {
				GeeIterator* _tmp7_;
				gboolean _tmp8_ = FALSE;
				GeeIterator* _tmp9_;
				gpointer _tmp10_ = NULL;
				FolksIndividual* candidate_ind;
				gboolean _tmp11_ = FALSE;
				gboolean _tmp12_ = FALSE;
				gboolean _tmp13_ = FALSE;
				FolksIndividual* _tmp14_;
				gboolean _tmp18_;
				gboolean _tmp22_;
				gboolean _tmp26_;
				_tmp7_ = _candidate_ind_it;
				_tmp8_ = gee_iterator_next (_tmp7_);
				if (!_tmp8_) {
					break;
				}
				_tmp9_ = _candidate_ind_it;
				_tmp10_ = gee_iterator_get (_tmp9_);
				candidate_ind = (FolksIndividual*) _tmp10_;
				_tmp14_ = candidate_ind;
				if (_tmp14_ != NULL) {
					FolksIndividual* _tmp15_;
					FolksTrustLevel _tmp16_;
					FolksTrustLevel _tmp17_;
					_tmp15_ = candidate_ind;
					_tmp16_ = folks_individual_get_trust_level (G_TYPE_CHECK_INSTANCE_CAST (_tmp15_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
					_tmp17_ = _tmp16_;
					_tmp13_ = _tmp17_ != FOLKS_TRUST_LEVEL_NONE;
				} else {
					_tmp13_ = FALSE;
				}
				_tmp18_ = _tmp13_;
				if (_tmp18_) {
					FolksIndividual* _tmp19_;
					FolksPersona* _tmp20_;
					gboolean _tmp21_ = FALSE;
					_tmp19_ = candidate_ind;
					_tmp20_ = _data5_->persona;
					_tmp21_ = folks_individual_has_anti_link_with_persona (G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), _tmp20_);
					_tmp12_ = _tmp21_ == FALSE;
				} else {
					_tmp12_ = FALSE;
				}
				_tmp22_ = _tmp12_;
				if (_tmp22_) {
					GeeHashSet* _tmp23_;
					FolksIndividual* _tmp24_;
					gboolean _tmp25_ = FALSE;
					_tmp23_ = _data5_->candidate_inds;
					_tmp24_ = candidate_ind;
					_tmp25_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp23_, G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
					_tmp11_ = _tmp25_;
				} else {
					_tmp11_ = FALSE;
				}
				_tmp26_ = _tmp11_;
				if (_tmp26_) {
					FolksIndividual* _tmp27_;
					const gchar* _tmp28_;
					const gchar* _tmp29_;
					const gchar* _tmp30_;
					const gchar* _tmp31_;
					_tmp27_ = candidate_ind;
					_tmp28_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp27_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
					_tmp29_ = _tmp28_;
					_tmp30_ = _data6_->prop_name;
					_tmp31_ = prop_linking_value;
					g_debug ("    Found candidate individual '%s'" " by linkable property '%s' = '%s'.", _tmp29_, _tmp30_, _tmp31_);
				}
				_g_object_unref0 (candidate_ind);
			}
			_g_object_unref0 (_candidate_ind_it);
		}
	}
	_g_object_unref0 (candidate_ind_set);
}


static void ________lambda62__folks_persona_linkable_property_callback (const gchar* link, gpointer self) {
	_______lambda62_ (self, link);
}


static void _folks_individual_aggregator_add_personas (FolksIndividualAggregator* self, GeeSet* added, FolksIndividual** user, GeeHashMultiMap** individuals_changes) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (added != NULL);
	g_return_if_fail (*individuals_changes != NULL);
	{
		GeeSet* _tmp0_;
		GeeIterator* _tmp1_ = NULL;
		GeeIterator* _persona_it;
		_tmp0_ = added;
		_tmp1_ = gee_iterable_iterator ((GeeIterable*) _tmp0_);
		_persona_it = _tmp1_;
		while (TRUE) {
			Block5Data* _data5_;
			GeeIterator* _tmp2_;
			gboolean _tmp3_ = FALSE;
			GeeIterator* _tmp4_;
			gpointer _tmp5_ = NULL;
			FolksPersona* _tmp6_;
			FolksPersonaStore* _tmp7_;
			FolksPersonaStore* _tmp8_;
			FolksPersonaStoreTrust _tmp9_;
			FolksPersonaStoreTrust _tmp10_;
			FolksPersonaStoreTrust trust_level;
			GeeHashSet* _tmp11_;
			GeeHashSet* _tmp12_;
			GeeHashSet* final_personas;
			FolksPersona* _tmp13_;
			const gchar* _tmp14_;
			const gchar* _tmp15_;
			FolksPersona* _tmp16_;
			const gchar* _tmp17_;
			const gchar* _tmp18_;
			gboolean _tmp19_ = FALSE;
			gboolean _tmp20_ = FALSE;
			FolksPersona* _tmp21_;
			gboolean _tmp22_;
			gboolean _tmp23_;
			gboolean _tmp25_;
			gboolean _tmp29_;
			FolksPersonaStoreTrust _tmp35_;
			FolksPersona* _tmp70_;
			FolksPersonaStore* _tmp71_;
			FolksPersonaStore* _tmp72_;
			FolksPersonaStoreTrust _tmp73_;
			FolksPersonaStoreTrust _tmp74_;
			GeeHashSet* _tmp88_;
			FolksPersona* _tmp89_;
			gboolean _tmp90_ = FALSE;
			GeeHashSet* _tmp91_;
			gint _tmp92_;
			gint _tmp93_;
			gboolean _tmp95_;
			GeeHashSet* _tmp109_;
			FolksIndividual* _tmp110_;
			FolksIndividual* final_individual;
			FolksIndividual* _tmp111_;
			const gchar* _tmp112_;
			const gchar* _tmp113_;
			FolksIndividual* _tmp114_;
			guint num_mappings_added;
			guint _tmp175_;
			FolksIndividual* _tmp178_;
			gboolean _tmp179_;
			gboolean _tmp180_;
			_data5_ = g_slice_new0 (Block5Data);
			_data5_->_ref_count_ = 1;
			_data5_->self = g_object_ref (self);
			_tmp2_ = _persona_it;
			_tmp3_ = gee_iterator_next (_tmp2_);
			if (!_tmp3_) {
				block5_data_unref (_data5_);
				_data5_ = NULL;
				break;
			}
			_tmp4_ = _persona_it;
			_tmp5_ = gee_iterator_get (_tmp4_);
			_data5_->persona = (FolksPersona*) _tmp5_;
			_tmp6_ = _data5_->persona;
			_tmp7_ = folks_persona_get_store (_tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = folks_persona_store_get_trust_level (_tmp8_);
			_tmp10_ = _tmp9_;
			trust_level = _tmp10_;
			_tmp11_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
			_data5_->candidate_inds = _tmp11_;
			_tmp12_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
			final_personas = _tmp12_;
			_tmp13_ = _data5_->persona;
			_tmp14_ = folks_persona_get_uid (_tmp13_);
			_tmp15_ = _tmp14_;
			_tmp16_ = _data5_->persona;
			_tmp17_ = folks_persona_get_iid (_tmp16_);
			_tmp18_ = _tmp17_;
			g_debug ("individual-aggregator.vala:1018: Aggregating persona '%s' on '%s'.", _tmp15_, _tmp18_);
			_tmp21_ = _data5_->persona;
			_tmp22_ = folks_persona_get_is_user (_tmp21_);
			_tmp23_ = _tmp22_;
			if (_tmp23_ == TRUE) {
				FolksIndividual* _tmp24_;
				_tmp24_ = *user;
				_tmp20_ = _tmp24_ != NULL;
			} else {
				_tmp20_ = FALSE;
			}
			_tmp25_ = _tmp20_;
			if (_tmp25_) {
				FolksIndividual* _tmp26_;
				FolksPersona* _tmp27_;
				gboolean _tmp28_ = FALSE;
				_tmp26_ = *user;
				_tmp27_ = _data5_->persona;
				_tmp28_ = folks_individual_has_anti_link_with_persona (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), _tmp27_);
				_tmp19_ = _tmp28_ == FALSE;
			} else {
				_tmp19_ = FALSE;
			}
			_tmp29_ = _tmp19_;
			if (_tmp29_) {
				FolksIndividual* _tmp30_;
				const gchar* _tmp31_;
				const gchar* _tmp32_;
				GeeHashSet* _tmp33_;
				FolksIndividual* _tmp34_;
				_tmp30_ = *user;
				_tmp31_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
				_tmp32_ = _tmp31_;
				g_debug ("individual-aggregator.vala:1025:     Found candidate individual '%s' a" \
"s user.", _tmp32_);
				_tmp33_ = _data5_->candidate_inds;
				_tmp34_ = *user;
				gee_abstract_collection_add ((GeeAbstractCollection*) _tmp33_, G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
			}
			_tmp35_ = trust_level;
			if (_tmp35_ != FOLKS_PERSONA_STORE_TRUST_NONE) {
				GeeHashMultiMap* _tmp36_;
				FolksPersona* _tmp37_;
				const gchar* _tmp38_;
				const gchar* _tmp39_;
				GeeCollection* _tmp40_ = NULL;
				GeeCollection* candidate_ind_set;
				GeeCollection* _tmp41_;
				_tmp36_ = self->priv->_link_map;
				_tmp37_ = _data5_->persona;
				_tmp38_ = folks_persona_get_iid (_tmp37_);
				_tmp39_ = _tmp38_;
				_tmp40_ = gee_multi_map_get ((GeeMultiMap*) _tmp36_, _tmp39_);
				candidate_ind_set = _tmp40_;
				_tmp41_ = candidate_ind_set;
				if (_tmp41_ != NULL) {
					{
						GeeCollection* _tmp42_;
						GeeIterator* _tmp43_ = NULL;
						GeeIterator* _candidate_ind_it;
						_tmp42_ = candidate_ind_set;
						_tmp43_ = gee_iterable_iterator ((GeeIterable*) _tmp42_);
						_candidate_ind_it = _tmp43_;
						while (TRUE) {
							GeeIterator* _tmp44_;
							gboolean _tmp45_ = FALSE;
							GeeIterator* _tmp46_;
							gpointer _tmp47_ = NULL;
							FolksIndividual* candidate_ind;
							gboolean _tmp48_ = FALSE;
							gboolean _tmp49_ = FALSE;
							gboolean _tmp50_ = FALSE;
							FolksIndividual* _tmp51_;
							gboolean _tmp55_;
							gboolean _tmp59_;
							gboolean _tmp63_;
							_tmp44_ = _candidate_ind_it;
							_tmp45_ = gee_iterator_next (_tmp44_);
							if (!_tmp45_) {
								break;
							}
							_tmp46_ = _candidate_ind_it;
							_tmp47_ = gee_iterator_get (_tmp46_);
							candidate_ind = (FolksIndividual*) _tmp47_;
							_tmp51_ = candidate_ind;
							if (_tmp51_ != NULL) {
								FolksIndividual* _tmp52_;
								FolksTrustLevel _tmp53_;
								FolksTrustLevel _tmp54_;
								_tmp52_ = candidate_ind;
								_tmp53_ = folks_individual_get_trust_level (G_TYPE_CHECK_INSTANCE_CAST (_tmp52_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
								_tmp54_ = _tmp53_;
								_tmp50_ = _tmp54_ != FOLKS_TRUST_LEVEL_NONE;
							} else {
								_tmp50_ = FALSE;
							}
							_tmp55_ = _tmp50_;
							if (_tmp55_) {
								FolksIndividual* _tmp56_;
								FolksPersona* _tmp57_;
								gboolean _tmp58_ = FALSE;
								_tmp56_ = candidate_ind;
								_tmp57_ = _data5_->persona;
								_tmp58_ = folks_individual_has_anti_link_with_persona (G_TYPE_CHECK_INSTANCE_CAST (_tmp56_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), _tmp57_);
								_tmp49_ = _tmp58_ == FALSE;
							} else {
								_tmp49_ = FALSE;
							}
							_tmp59_ = _tmp49_;
							if (_tmp59_) {
								GeeHashSet* _tmp60_;
								FolksIndividual* _tmp61_;
								gboolean _tmp62_ = FALSE;
								_tmp60_ = _data5_->candidate_inds;
								_tmp61_ = candidate_ind;
								_tmp62_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp60_, G_TYPE_CHECK_INSTANCE_CAST (_tmp61_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
								_tmp48_ = _tmp62_;
							} else {
								_tmp48_ = FALSE;
							}
							_tmp63_ = _tmp48_;
							if (_tmp63_) {
								FolksIndividual* _tmp64_;
								const gchar* _tmp65_;
								const gchar* _tmp66_;
								FolksPersona* _tmp67_;
								const gchar* _tmp68_;
								const gchar* _tmp69_;
								_tmp64_ = candidate_ind;
								_tmp65_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp64_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
								_tmp66_ = _tmp65_;
								_tmp67_ = _data5_->persona;
								_tmp68_ = folks_persona_get_iid (_tmp67_);
								_tmp69_ = _tmp68_;
								g_debug ("    Found candidate individual '%s' by " "IID '%s'.", _tmp66_, _tmp69_);
							}
							_g_object_unref0 (candidate_ind);
						}
						_g_object_unref0 (_candidate_ind_it);
					}
				}
				_g_object_unref0 (candidate_ind_set);
			}
			_tmp70_ = _data5_->persona;
			_tmp71_ = folks_persona_get_store (_tmp70_);
			_tmp72_ = _tmp71_;
			_tmp73_ = folks_persona_store_get_trust_level (_tmp72_);
			_tmp74_ = _tmp73_;
			if (_tmp74_ == FOLKS_PERSONA_STORE_TRUST_FULL) {
				FolksPersona* _tmp75_;
				gchar** _tmp76_;
				gint _tmp76__length1;
				gchar** _tmp77_;
				gint _tmp77__length1;
				_tmp75_ = _data5_->persona;
				_tmp76_ = folks_persona_get_linkable_properties (_tmp75_, &_tmp76__length1);
				_tmp77_ = _tmp76_;
				_tmp77__length1 = _tmp76__length1;
				{
					gchar** foo_collection = NULL;
					gint foo_collection_length1 = 0;
					gint _foo_collection_size_ = 0;
					gint foo_it = 0;
					foo_collection = _tmp77_;
					foo_collection_length1 = _tmp77__length1;
					for (foo_it = 0; foo_it < _tmp77__length1; foo_it = foo_it + 1) {
						const gchar* foo = NULL;
						foo = foo_collection[foo_it];
						{
							Block6Data* _data6_;
							const gchar* _tmp78_;
							FolksPersona* _tmp79_;
							GObjectClass* _tmp80_ = NULL;
							GObjectClass* pclass;
							GObjectClass* _tmp81_;
							const gchar* _tmp82_;
							GParamSpec* _tmp83_ = NULL;
							FolksPersona* _tmp86_;
							const gchar* _tmp87_;
							_data6_ = g_slice_new0 (Block6Data);
							_data6_->_ref_count_ = 1;
							_data6_->_data5_ = block5_data_ref (_data5_);
							_tmp78_ = foo;
							_data6_->prop_name = _tmp78_;
							_tmp79_ = _data5_->persona;
							_tmp80_ = G_OBJECT_GET_CLASS ((GObject*) _tmp79_);
							pclass = _tmp80_;
							_tmp81_ = pclass;
							_tmp82_ = _data6_->prop_name;
							_tmp83_ = g_object_class_find_property (_tmp81_, _tmp82_);
							if (_tmp83_ == NULL) {
								const gchar* _tmp84_ = NULL;
								const gchar* _tmp85_;
								_tmp84_ = _ ("Unknown property '%s' in linkable property list.");
								_tmp85_ = _data6_->prop_name;
								g_warning (_tmp84_, _tmp85_);
								block6_data_unref (_data6_);
								_data6_ = NULL;
								continue;
							}
							_tmp86_ = _data5_->persona;
							_tmp87_ = _data6_->prop_name;
							folks_persona_linkable_property_to_links (_tmp86_, _tmp87_, ________lambda62__folks_persona_linkable_property_callback, _data6_);
							block6_data_unref (_data6_);
							_data6_ = NULL;
						}
					}
				}
			}
			_tmp88_ = final_personas;
			_tmp89_ = _data5_->persona;
			gee_abstract_collection_add ((GeeAbstractCollection*) _tmp88_, _tmp89_);
			_tmp91_ = _data5_->candidate_inds;
			_tmp92_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp91_);
			_tmp93_ = _tmp92_;
			if (_tmp93_ > 0) {
				gboolean _tmp94_;
				_tmp94_ = self->priv->_linking_enabled;
				_tmp90_ = _tmp94_ == TRUE;
			} else {
				_tmp90_ = FALSE;
			}
			_tmp95_ = _tmp90_;
			if (_tmp95_) {
				{
					GeeHashSet* _tmp96_;
					GeeIterator* _tmp97_ = NULL;
					GeeIterator* _individual_it;
					_tmp96_ = _data5_->candidate_inds;
					_tmp97_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp96_);
					_individual_it = _tmp97_;
					while (TRUE) {
						GeeIterator* _tmp98_;
						gboolean _tmp99_ = FALSE;
						GeeIterator* _tmp100_;
						gpointer _tmp101_ = NULL;
						FolksIndividual* individual;
						GeeHashSet* _tmp102_;
						FolksIndividual* _tmp103_;
						GeeSet* _tmp104_;
						GeeSet* _tmp105_;
						_tmp98_ = _individual_it;
						_tmp99_ = gee_iterator_next (_tmp98_);
						if (!_tmp99_) {
							break;
						}
						_tmp100_ = _individual_it;
						_tmp101_ = gee_iterator_get (_tmp100_);
						individual = (FolksIndividual*) _tmp101_;
						_tmp102_ = final_personas;
						_tmp103_ = individual;
						_tmp104_ = folks_individual_get_personas (_tmp103_);
						_tmp105_ = _tmp104_;
						gee_abstract_collection_add_all ((GeeAbstractCollection*) _tmp102_, (GeeCollection*) _tmp105_);
						_g_object_unref0 (individual);
					}
					_g_object_unref0 (_individual_it);
				}
			} else {
				GeeHashSet* _tmp106_;
				gint _tmp107_;
				gint _tmp108_;
				_tmp106_ = _data5_->candidate_inds;
				_tmp107_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp106_);
				_tmp108_ = _tmp107_;
				if (_tmp108_ > 0) {
					g_debug ("individual-aggregator.vala:1120:     Linking disabled.");
				} else {
					g_debug ("individual-aggregator.vala:1124:     Did not find any candidate indivi" \
"duals.");
				}
			}
			_tmp109_ = final_personas;
			_tmp110_ = folks_individual_new ((GeeSet*) _tmp109_);
			final_individual = _tmp110_;
			_tmp111_ = final_individual;
			_tmp112_ = folks_individual_get_id (_tmp111_);
			_tmp113_ = _tmp112_;
			_tmp114_ = final_individual;
			g_debug ("individual-aggregator.vala:1129:     Created new individual '%s' (%p) " \
"with personas:", _tmp113_, _tmp114_);
			{
				GeeHashSet* _tmp115_;
				GeeIterator* _tmp116_ = NULL;
				GeeIterator* _p_it;
				_tmp115_ = final_personas;
				_tmp116_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp115_);
				_p_it = _tmp116_;
				while (TRUE) {
					GeeIterator* _tmp117_;
					gboolean _tmp118_ = FALSE;
					GeeIterator* _tmp119_;
					gpointer _tmp120_ = NULL;
					FolksPersona* p;
					FolksPersona* _tmp121_;
					const gchar* _tmp122_;
					const gchar* _tmp123_;
					FolksPersona* _tmp124_;
					FolksPersona* _tmp125_;
					FolksIndividual* _tmp126_;
					_tmp117_ = _p_it;
					_tmp118_ = gee_iterator_next (_tmp117_);
					if (!_tmp118_) {
						break;
					}
					_tmp119_ = _p_it;
					_tmp120_ = gee_iterator_get (_tmp119_);
					p = (FolksPersona*) _tmp120_;
					_tmp121_ = p;
					_tmp122_ = folks_persona_get_uid (_tmp121_);
					_tmp123_ = _tmp122_;
					_tmp124_ = p;
					g_debug ("individual-aggregator.vala:1133:         %s (%p)", _tmp123_, _tmp124_);
					_tmp125_ = p;
					_tmp126_ = final_individual;
					_folks_individual_aggregator_add_persona_to_link_map (self, _tmp125_, _tmp126_);
					_g_object_unref0 (p);
				}
				_g_object_unref0 (_p_it);
			}
			num_mappings_added = (guint) 0;
			{
				GeeHashSet* _tmp127_;
				GeeIterator* _tmp128_ = NULL;
				GeeIterator* _i_it;
				_tmp127_ = _data5_->candidate_inds;
				_tmp128_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp127_);
				_i_it = _tmp128_;
				while (TRUE) {
					GeeIterator* _tmp129_;
					gboolean _tmp130_ = FALSE;
					GeeIterator* _tmp131_;
					gpointer _tmp132_ = NULL;
					FolksIndividual* i;
					FolksIndividual* _tmp133_;
					GeeHashSet* _tmp134_;
					GeeHashSet* transitive_updates;
					GeeHashSet* _tmp168_;
					gint _tmp169_;
					gint _tmp170_;
					_tmp129_ = _i_it;
					_tmp130_ = gee_iterator_next (_tmp129_);
					if (!_tmp130_) {
						break;
					}
					_tmp131_ = _i_it;
					_tmp132_ = gee_iterator_get (_tmp131_);
					i = (FolksIndividual*) _tmp132_;
					_tmp133_ = i;
					_folks_individual_aggregator_remove_individual_from_link_map (self, _tmp133_);
					_tmp134_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
					transitive_updates = _tmp134_;
					{
						GeeHashMultiMap* _tmp135_;
						GeeSet* _tmp136_ = NULL;
						GeeSet* _tmp137_;
						GeeIterator* _tmp138_ = NULL;
						GeeIterator* _tmp139_;
						GeeIterator* _k_it;
						_tmp135_ = *individuals_changes;
						_tmp136_ = gee_multi_map_get_keys ((GeeMultiMap*) _tmp135_);
						_tmp137_ = _tmp136_;
						_tmp138_ = gee_iterable_iterator ((GeeIterable*) _tmp137_);
						_tmp139_ = _tmp138_;
						_g_object_unref0 (_tmp137_);
						_k_it = _tmp139_;
						while (TRUE) {
							GeeIterator* _tmp140_;
							gboolean _tmp141_ = FALSE;
							GeeIterator* _tmp142_;
							gpointer _tmp143_ = NULL;
							FolksIndividual* k;
							GeeHashMultiMap* _tmp144_;
							FolksIndividual* _tmp145_;
							GeeCollection* _tmp146_ = NULL;
							GeeCollection* _tmp147_;
							FolksIndividual* _tmp148_;
							gboolean _tmp149_ = FALSE;
							gboolean _tmp150_;
							_tmp140_ = _k_it;
							_tmp141_ = gee_iterator_next (_tmp140_);
							if (!_tmp141_) {
								break;
							}
							_tmp142_ = _k_it;
							_tmp143_ = gee_iterator_get (_tmp142_);
							k = (FolksIndividual*) _tmp143_;
							_tmp144_ = *individuals_changes;
							_tmp145_ = k;
							_tmp146_ = gee_multi_map_get ((GeeMultiMap*) _tmp144_, _tmp145_);
							_tmp147_ = _tmp146_;
							_tmp148_ = i;
							_tmp149_ = gee_collection_contains (_tmp147_, _tmp148_);
							_tmp150_ = _tmp149_;
							_g_object_unref0 (_tmp147_);
							if (_tmp150_) {
								GeeHashSet* _tmp151_;
								FolksIndividual* _tmp152_;
								_tmp151_ = transitive_updates;
								_tmp152_ = k;
								gee_abstract_collection_add ((GeeAbstractCollection*) _tmp151_, _tmp152_);
							}
							_g_object_unref0 (k);
						}
						_g_object_unref0 (_k_it);
					}
					{
						GeeHashSet* _tmp153_;
						GeeIterator* _tmp154_ = NULL;
						GeeIterator* _k_it;
						_tmp153_ = transitive_updates;
						_tmp154_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp153_);
						_k_it = _tmp154_;
						while (TRUE) {
							GeeIterator* _tmp155_;
							gboolean _tmp156_ = FALSE;
							GeeIterator* _tmp157_;
							gpointer _tmp158_ = NULL;
							FolksIndividual* k;
							GeeHashMultiMap* _tmp159_;
							FolksIndividual* _tmp160_;
							FolksIndividual* _tmp161_;
							gboolean _tmp162_ = FALSE;
							FolksIndividual* _tmp163_;
							_tmp155_ = _k_it;
							_tmp156_ = gee_iterator_next (_tmp155_);
							if (!_tmp156_) {
								break;
							}
							_tmp157_ = _k_it;
							_tmp158_ = gee_iterator_get (_tmp157_);
							k = (FolksIndividual*) _tmp158_;
							_tmp159_ = *individuals_changes;
							_tmp160_ = k;
							_tmp161_ = i;
							_tmp162_ = gee_multi_map_remove ((GeeMultiMap*) _tmp159_, _tmp160_, _tmp161_);
							_vala_assert (_tmp162_ == TRUE, "individuals_changes.remove (k, i) == true");
							_tmp163_ = k;
							if (_tmp163_ != NULL) {
								GeeHashMultiMap* _tmp164_;
								FolksIndividual* _tmp165_;
								FolksIndividual* _tmp166_;
								guint _tmp167_;
								_tmp164_ = *individuals_changes;
								_tmp165_ = k;
								_tmp166_ = final_individual;
								gee_multi_map_set ((GeeMultiMap*) _tmp164_, _tmp165_, _tmp166_);
								_tmp167_ = num_mappings_added;
								num_mappings_added = _tmp167_ + 1;
							}
							_g_object_unref0 (k);
						}
						_g_object_unref0 (_k_it);
					}
					_tmp168_ = transitive_updates;
					_tmp169_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp168_);
					_tmp170_ = _tmp169_;
					if (_tmp170_ == 0) {
						GeeHashMultiMap* _tmp171_;
						FolksIndividual* _tmp172_;
						FolksIndividual* _tmp173_;
						guint _tmp174_;
						_tmp171_ = *individuals_changes;
						_tmp172_ = i;
						_tmp173_ = final_individual;
						gee_multi_map_set ((GeeMultiMap*) _tmp171_, _tmp172_, _tmp173_);
						_tmp174_ = num_mappings_added;
						num_mappings_added = _tmp174_ + 1;
					}
					_g_object_unref0 (transitive_updates);
					_g_object_unref0 (i);
				}
				_g_object_unref0 (_i_it);
			}
			_tmp175_ = num_mappings_added;
			if (_tmp175_ == ((guint) 0)) {
				GeeHashMultiMap* _tmp176_;
				FolksIndividual* _tmp177_;
				_tmp176_ = *individuals_changes;
				_tmp177_ = final_individual;
				gee_multi_map_set ((GeeMultiMap*) _tmp176_, NULL, _tmp177_);
			}
			_tmp178_ = final_individual;
			_tmp179_ = folks_individual_get_is_user (_tmp178_);
			_tmp180_ = _tmp179_;
			if (_tmp180_ == TRUE) {
				FolksIndividual* _tmp181_;
				FolksIndividual* _tmp182_;
				_tmp181_ = final_individual;
				_tmp182_ = _g_object_ref0 (_tmp181_);
				_g_object_unref0 (*user);
				*user = _tmp182_;
			}
			_g_object_unref0 (final_individual);
			_g_object_unref0 (final_personas);
			block5_data_unref (_data5_);
			_data5_ = NULL;
		}
		_g_object_unref0 (_persona_it);
	}
}


static void _folks_individual_aggregator_persona_linkable_property_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec) {
	GObject* _tmp0_;
	FolksPersona* _tmp1_;
	FolksPersona* persona;
	const gchar* _tmp2_ = NULL;
	FolksPersona* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	GParamSpec* _tmp6_;
	const gchar* _tmp7_;
	FolksPersona* _tmp8_;
	const gchar* _tmp9_;
	const gchar* _tmp10_;
	const gchar* _tmp11_;
	FolksPersona* _tmp12_;
	const gchar* _tmp13_;
	const gchar* _tmp14_;
	GeeHashSet* _tmp15_;
	GeeHashSet* persona_set;
	FolksPersona* _tmp16_;
	FolksPersona* _tmp17_;
	FolksPersonaStore* _tmp18_;
	FolksPersonaStore* _tmp19_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (obj != NULL);
	g_return_if_fail (pspec != NULL);
	_tmp0_ = obj;
	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, FOLKS_TYPE_PERSONA) ? ((FolksPersona*) _tmp0_) : NULL, FOLKS_TYPE_PERSONA, FolksPersona));
	persona = _tmp1_;
	_tmp3_ = persona;
	_tmp4_ = folks_persona_get_is_user (_tmp3_);
	_tmp5_ = _tmp4_;
	if (_tmp5_) {
		_tmp2_ = "yes";
	} else {
		_tmp2_ = "no";
	}
	_tmp6_ = pspec;
	_tmp7_ = _tmp6_->name;
	_tmp8_ = persona;
	_tmp9_ = folks_persona_get_uid (_tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = _tmp2_;
	_tmp12_ = persona;
	_tmp13_ = folks_persona_get_iid (_tmp12_);
	_tmp14_ = _tmp13_;
	g_debug ("Linkable property '%s' changed for persona '%s' " "(is user: %s, IID: %s).", _tmp7_, _tmp10_, _tmp11_, _tmp14_);
	_tmp15_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	persona_set = _tmp15_;
	_tmp16_ = persona;
	gee_abstract_collection_add ((GeeAbstractCollection*) persona_set, _tmp16_);
	_tmp17_ = persona;
	_tmp18_ = folks_persona_get_store (_tmp17_);
	_tmp19_ = _tmp18_;
	_folks_individual_aggregator_personas_changed_cb (self, _tmp19_, (GeeSet*) persona_set, (GeeSet*) persona_set, NULL, NULL, FOLKS_GROUP_DETAILS_CHANGE_REASON_NONE);
	_g_object_unref0 (persona_set);
	_g_object_unref0 (persona);
}


static void _folks_individual_aggregator_persona_anti_links_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec) {
	GObject* _tmp0_;
	FolksPersona* _tmp1_;
	FolksPersona* persona;
	const gchar* _tmp2_ = NULL;
	FolksPersona* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	FolksPersona* _tmp6_;
	const gchar* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	FolksPersona* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	GeeHashSet* _tmp13_;
	GeeHashSet* persona_set;
	FolksPersona* _tmp14_;
	FolksPersona* _tmp15_;
	FolksPersonaStore* _tmp16_;
	FolksPersonaStore* _tmp17_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (obj != NULL);
	g_return_if_fail (pspec != NULL);
	_tmp0_ = obj;
	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, FOLKS_TYPE_PERSONA) ? ((FolksPersona*) _tmp0_) : NULL);
	persona = _tmp1_;
	_tmp3_ = persona;
	_tmp4_ = folks_persona_get_is_user (_tmp3_);
	_tmp5_ = _tmp4_;
	if (_tmp5_) {
		_tmp2_ = "yes";
	} else {
		_tmp2_ = "no";
	}
	_tmp6_ = persona;
	_tmp7_ = folks_persona_get_uid (_tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = _tmp2_;
	_tmp10_ = persona;
	_tmp11_ = folks_persona_get_iid (_tmp10_);
	_tmp12_ = _tmp11_;
	g_debug ("individual-aggregator.vala:1225: Anti-links changed for persona '%s' (" \
"is user: %s, IID: %s).", _tmp8_, _tmp9_, _tmp12_);
	_tmp13_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	persona_set = _tmp13_;
	_tmp14_ = persona;
	gee_abstract_collection_add ((GeeAbstractCollection*) persona_set, _tmp14_);
	_tmp15_ = persona;
	_tmp16_ = folks_persona_get_store (_tmp15_);
	_tmp17_ = _tmp16_;
	_folks_individual_aggregator_personas_changed_cb (self, _tmp17_, (GeeSet*) persona_set, (GeeSet*) persona_set, NULL, NULL, FOLKS_GROUP_DETAILS_CHANGE_REASON_NONE);
	_g_object_unref0 (persona_set);
	_g_object_unref0 (persona);
}


static void __folks_individual_aggregator_persona_linkable_property_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
	_folks_individual_aggregator_persona_linkable_property_changed_cb (self, _sender, pspec);
}


static void __folks_individual_aggregator_persona_anti_links_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
	_folks_individual_aggregator_persona_anti_links_changed_cb (self, _sender, pspec);
}


static void _folks_individual_aggregator_connect_to_persona (FolksIndividualAggregator* self, FolksPersona* persona) {
	FolksPersona* _tmp0_;
	gchar** _tmp1_;
	gint _tmp1__length1;
	gchar** _tmp2_;
	gint _tmp2__length1;
	FolksPersona* _tmp7_;
	FolksAntiLinkable* _tmp8_;
	FolksAntiLinkable* al;
	FolksAntiLinkable* _tmp9_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (persona != NULL);
	_tmp0_ = persona;
	_tmp1_ = folks_persona_get_linkable_properties (_tmp0_, &_tmp1__length1);
	_tmp2_ = _tmp1_;
	_tmp2__length1 = _tmp1__length1;
	{
		gchar** prop_name_collection = NULL;
		gint prop_name_collection_length1 = 0;
		gint _prop_name_collection_size_ = 0;
		gint prop_name_it = 0;
		prop_name_collection = _tmp2_;
		prop_name_collection_length1 = _tmp2__length1;
		for (prop_name_it = 0; prop_name_it < _tmp2__length1; prop_name_it = prop_name_it + 1) {
			gchar* _tmp3_;
			gchar* prop_name = NULL;
			_tmp3_ = g_strdup (prop_name_collection[prop_name_it]);
			prop_name = _tmp3_;
			{
				FolksPersona* _tmp4_;
				const gchar* _tmp5_;
				gchar* _tmp6_;
				_tmp4_ = persona;
				_tmp5_ = prop_name;
				_tmp6_ = g_strconcat ("notify::", _tmp5_, NULL);
				g_signal_connect_object ((GObject*) _tmp4_, _tmp6_, (GCallback) __folks_individual_aggregator_persona_linkable_property_changed_cb_g_object_notify, self, 0);
				_g_free0 (_tmp6_);
				_g_free0 (prop_name);
			}
		}
	}
	_tmp7_ = persona;
	_tmp8_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, FOLKS_TYPE_ANTI_LINKABLE) ? ((FolksAntiLinkable*) _tmp7_) : NULL);
	al = _tmp8_;
	_tmp9_ = al;
	if (_tmp9_ != NULL) {
		FolksAntiLinkable* _tmp10_;
		_tmp10_ = al;
		g_signal_connect_object ((GObject*) _tmp10_, "notify::anti-links", (GCallback) __folks_individual_aggregator_persona_anti_links_changed_cb_g_object_notify, self, 0);
	}
	_g_object_unref0 (al);
}


static void _folks_individual_aggregator_disconnect_from_persona (FolksIndividualAggregator* self, FolksPersona* persona) {
	FolksPersona* _tmp0_;
	FolksAntiLinkable* _tmp1_;
	FolksAntiLinkable* al;
	FolksAntiLinkable* _tmp2_;
	FolksPersona* _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	gchar** _tmp8_;
	gint _tmp8__length1;
	g_return_if_fail (self != NULL);
	g_return_if_fail (persona != NULL);
	_tmp0_ = persona;
	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, FOLKS_TYPE_ANTI_LINKABLE) ? ((FolksAntiLinkable*) _tmp0_) : NULL);
	al = _tmp1_;
	_tmp2_ = al;
	if (_tmp2_ != NULL) {
		FolksAntiLinkable* _tmp3_;
		guint _tmp4_ = 0U;
		GQuark _tmp5_ = 0U;
		_tmp3_ = al;
		g_signal_parse_name ("notify::anti-links", G_TYPE_OBJECT, &_tmp4_, &_tmp5_, TRUE);
		g_signal_handlers_disconnect_matched ((GObject*) _tmp3_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp4_, _tmp5_, NULL, (GCallback) __folks_individual_aggregator_persona_anti_links_changed_cb_g_object_notify, self);
	}
	_tmp6_ = persona;
	_tmp7_ = folks_persona_get_linkable_properties (_tmp6_, &_tmp7__length1);
	_tmp8_ = _tmp7_;
	_tmp8__length1 = _tmp7__length1;
	{
		gchar** prop_name_collection = NULL;
		gint prop_name_collection_length1 = 0;
		gint _prop_name_collection_size_ = 0;
		gint prop_name_it = 0;
		prop_name_collection = _tmp8_;
		prop_name_collection_length1 = _tmp8__length1;
		for (prop_name_it = 0; prop_name_it < _tmp8__length1; prop_name_it = prop_name_it + 1) {
			gchar* _tmp9_;
			gchar* prop_name = NULL;
			_tmp9_ = g_strdup (prop_name_collection[prop_name_it]);
			prop_name = _tmp9_;
			{
				FolksPersona* _tmp10_;
				const gchar* _tmp11_;
				gchar* _tmp12_;
				guint _tmp13_ = 0U;
				GQuark _tmp14_ = 0U;
				_tmp10_ = persona;
				_tmp11_ = prop_name;
				_tmp12_ = g_strconcat ("notify::", _tmp11_, NULL);
				g_signal_parse_name (_tmp12_, G_TYPE_OBJECT, &_tmp13_, &_tmp14_, TRUE);
				g_signal_handlers_disconnect_matched ((GObject*) _tmp10_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp13_, _tmp14_, NULL, (GCallback) __folks_individual_aggregator_persona_linkable_property_changed_cb_g_object_notify, self);
				_g_free0 (_tmp12_);
				_g_free0 (prop_name);
			}
		}
	}
	_g_object_unref0 (al);
}


static Block7Data* block7_data_ref (Block7Data* _data7_) {
	g_atomic_int_inc (&_data7_->_ref_count_);
	return _data7_;
}


static void block7_data_unref (void * _userdata_) {
	Block7Data* _data7_;
	_data7_ = (Block7Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data7_->_ref_count_)) {
		FolksIndividualAggregator * self;
		self = _data7_->self;
		_g_object_unref0 (_data7_->individual);
		_g_object_unref0 (self);
		g_slice_free (Block7Data, _data7_);
	}
}


static void _____lambda63_ (Block7Data* _data7_, const gchar* l) {
	FolksIndividualAggregator * self;
	const gchar* _tmp0_;
	const gchar* prop_linking_value;
	GeeHashMultiMap* _tmp1_;
	FolksIndividual* _tmp2_;
	self = _data7_->self;
	g_return_if_fail (l != NULL);
	_tmp0_ = l;
	prop_linking_value = _tmp0_;
	g_debug ("individual-aggregator.vala:1304:             %s", prop_linking_value);
	_tmp1_ = self->priv->_link_map;
	_tmp2_ = _data7_->individual;
	gee_multi_map_set ((GeeMultiMap*) _tmp1_, prop_linking_value, _tmp2_);
}


static void ______lambda63__folks_persona_linkable_property_callback (const gchar* link, gpointer self) {
	_____lambda63_ (self, link);
}


static void _folks_individual_aggregator_add_persona_to_link_map (FolksIndividualAggregator* self, FolksPersona* persona, FolksIndividual* individual) {
	Block7Data* _data7_;
	FolksIndividual* _tmp0_;
	FolksIndividual* _tmp1_;
	const gchar* _tmp2_ = NULL;
	FolksPersona* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	FolksPersona* _tmp6_;
	const gchar* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	FolksPersona* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	FolksIndividual* _tmp13_;
	const gchar* _tmp14_;
	const gchar* _tmp15_;
	GeeHashMultiMap* _tmp16_;
	FolksPersona* _tmp17_;
	const gchar* _tmp18_;
	const gchar* _tmp19_;
	FolksIndividual* _tmp20_;
	FolksPersona* _tmp21_;
	FolksPersonaStore* _tmp22_;
	FolksPersonaStore* _tmp23_;
	FolksPersonaStoreTrust _tmp24_;
	FolksPersonaStoreTrust _tmp25_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (persona != NULL);
	g_return_if_fail (individual != NULL);
	_data7_ = g_slice_new0 (Block7Data);
	_data7_->_ref_count_ = 1;
	_data7_->self = g_object_ref (self);
	_tmp0_ = individual;
	_tmp1_ = _g_object_ref0 (_tmp0_);
	_g_object_unref0 (_data7_->individual);
	_data7_->individual = _tmp1_;
	_tmp3_ = persona;
	_tmp4_ = folks_persona_get_is_user (_tmp3_);
	_tmp5_ = _tmp4_;
	if (_tmp5_) {
		_tmp2_ = "yes";
	} else {
		_tmp2_ = "no";
	}
	_tmp6_ = persona;
	_tmp7_ = folks_persona_get_uid (_tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = _tmp2_;
	_tmp10_ = persona;
	_tmp11_ = folks_persona_get_iid (_tmp10_);
	_tmp12_ = _tmp11_;
	g_debug ("individual-aggregator.vala:1268: Connecting to Persona: %s (is user: %" \
"s, IID: %s)", _tmp8_, _tmp9_, _tmp12_);
	_tmp13_ = _data7_->individual;
	_tmp14_ = folks_individual_get_id (_tmp13_);
	_tmp15_ = _tmp14_;
	g_debug ("individual-aggregator.vala:1270:     Mapping to Individual: %s", _tmp15_);
	_tmp16_ = self->priv->_link_map;
	_tmp17_ = persona;
	_tmp18_ = folks_persona_get_iid (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = _data7_->individual;
	gee_multi_map_set ((GeeMultiMap*) _tmp16_, _tmp19_, _tmp20_);
	_tmp21_ = persona;
	_tmp22_ = folks_persona_get_store (_tmp21_);
	_tmp23_ = _tmp22_;
	_tmp24_ = folks_persona_store_get_trust_level (_tmp23_);
	_tmp25_ = _tmp24_;
	if (_tmp25_ == FOLKS_PERSONA_STORE_TRUST_FULL) {
		FolksPersona* _tmp26_;
		gchar** _tmp27_;
		gint _tmp27__length1;
		gchar** _tmp28_;
		gint _tmp28__length1;
		g_debug ("individual-aggregator.vala:1281:     Inserting links:");
		_tmp26_ = persona;
		_tmp27_ = folks_persona_get_linkable_properties (_tmp26_, &_tmp27__length1);
		_tmp28_ = _tmp27_;
		_tmp28__length1 = _tmp27__length1;
		{
			gchar** prop_name_collection = NULL;
			gint prop_name_collection_length1 = 0;
			gint _prop_name_collection_size_ = 0;
			gint prop_name_it = 0;
			prop_name_collection = _tmp28_;
			prop_name_collection_length1 = _tmp28__length1;
			for (prop_name_it = 0; prop_name_it < _tmp28__length1; prop_name_it = prop_name_it + 1) {
				const gchar* prop_name = NULL;
				prop_name = prop_name_collection[prop_name_it];
				{
					const gchar* _tmp29_;
					FolksPersona* _tmp30_;
					GObjectClass* _tmp31_ = NULL;
					GObjectClass* pclass;
					GObjectClass* _tmp32_;
					const gchar* _tmp33_;
					GParamSpec* _tmp34_ = NULL;
					FolksPersona* _tmp37_;
					const gchar* _tmp38_;
					_tmp29_ = prop_name;
					g_debug ("individual-aggregator.vala:1287:         %s", _tmp29_);
					_tmp30_ = persona;
					_tmp31_ = G_OBJECT_GET_CLASS ((GObject*) _tmp30_);
					pclass = _tmp31_;
					_tmp32_ = pclass;
					_tmp33_ = prop_name;
					_tmp34_ = g_object_class_find_property (_tmp32_, _tmp33_);
					if (_tmp34_ == NULL) {
						const gchar* _tmp35_ = NULL;
						const gchar* _tmp36_;
						_tmp35_ = _ ("Unknown property '%s' in linkable property list.");
						_tmp36_ = prop_name;
						g_warning (_tmp35_, _tmp36_);
						continue;
					}
					_tmp37_ = persona;
					_tmp38_ = prop_name;
					folks_persona_linkable_property_to_links (_tmp37_, _tmp38_, ______lambda63__folks_persona_linkable_property_callback, _data7_);
				}
			}
		}
	}
	block7_data_unref (_data7_);
	_data7_ = NULL;
}


static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static void _folks_individual_aggregator_remove_individual_from_link_map (FolksIndividualAggregator* self, FolksIndividual* individual) {
	FolksIndividual* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar** _tmp3_ = NULL;
	gchar** remove_keys;
	gint remove_keys_length1;
	gint _remove_keys_size_;
	gchar** _tmp28_;
	gint _tmp28__length1;
	g_return_if_fail (self != NULL);
	g_return_if_fail (individual != NULL);
	_tmp0_ = individual;
	_tmp1_ = folks_individual_get_id (_tmp0_);
	_tmp2_ = _tmp1_;
	g_debug ("individual-aggregator.vala:1319: Removing Individual '%s' from the lin" \
"k map.", _tmp2_);
	_tmp3_ = g_new0 (gchar*, 0 + 1);
	remove_keys = _tmp3_;
	remove_keys_length1 = 0;
	_remove_keys_size_ = remove_keys_length1;
	{
		GeeHashMultiMap* _tmp4_;
		GeeSet* _tmp5_ = NULL;
		GeeSet* _tmp6_;
		GeeIterator* _tmp7_ = NULL;
		GeeIterator* _tmp8_;
		GeeIterator* _link_key_it;
		_tmp4_ = self->priv->_link_map;
		_tmp5_ = gee_multi_map_get_keys ((GeeMultiMap*) _tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = gee_iterable_iterator ((GeeIterable*) _tmp6_);
		_tmp8_ = _tmp7_;
		_g_object_unref0 (_tmp6_);
		_link_key_it = _tmp8_;
		while (TRUE) {
			GeeIterator* _tmp9_;
			gboolean _tmp10_ = FALSE;
			GeeIterator* _tmp11_;
			gpointer _tmp12_ = NULL;
			gchar* link_key;
			GeeHashMultiMap* _tmp13_;
			const gchar* _tmp14_;
			GeeCollection* _tmp15_ = NULL;
			GeeCollection* _tmp16_;
			FolksIndividual* _tmp17_;
			gboolean _tmp18_ = FALSE;
			gboolean _tmp19_;
			_tmp9_ = _link_key_it;
			_tmp10_ = gee_iterator_next (_tmp9_);
			if (!_tmp10_) {
				break;
			}
			_tmp11_ = _link_key_it;
			_tmp12_ = gee_iterator_get (_tmp11_);
			link_key = (gchar*) _tmp12_;
			_tmp13_ = self->priv->_link_map;
			_tmp14_ = link_key;
			_tmp15_ = gee_multi_map_get ((GeeMultiMap*) _tmp13_, _tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = individual;
			_tmp18_ = gee_collection_contains (_tmp16_, _tmp17_);
			_tmp19_ = _tmp18_;
			_g_object_unref0 (_tmp16_);
			if (_tmp19_) {
				const gchar* _tmp20_;
				FolksIndividual* _tmp21_;
				const gchar* _tmp22_;
				const gchar* _tmp23_;
				FolksIndividual* _tmp24_;
				gchar** _tmp25_;
				gint _tmp25__length1;
				const gchar* _tmp26_;
				gchar* _tmp27_;
				_tmp20_ = link_key;
				_tmp21_ = individual;
				_tmp22_ = folks_individual_get_id (_tmp21_);
				_tmp23_ = _tmp22_;
				_tmp24_ = individual;
				g_debug ("individual-aggregator.vala:1330:     %s → %s (%p)", _tmp20_, _tmp23_, _tmp24_);
				_tmp25_ = remove_keys;
				_tmp25__length1 = remove_keys_length1;
				_tmp26_ = link_key;
				_tmp27_ = g_strdup (_tmp26_);
				_vala_array_add1 (&remove_keys, &remove_keys_length1, &_remove_keys_size_, _tmp27_);
			}
			_g_free0 (link_key);
		}
		_g_object_unref0 (_link_key_it);
	}
	_tmp28_ = remove_keys;
	_tmp28__length1 = remove_keys_length1;
	{
		gchar** link_key_collection = NULL;
		gint link_key_collection_length1 = 0;
		gint _link_key_collection_size_ = 0;
		gint link_key_it = 0;
		link_key_collection = _tmp28_;
		link_key_collection_length1 = _tmp28__length1;
		for (link_key_it = 0; link_key_it < _tmp28__length1; link_key_it = link_key_it + 1) {
			gchar* _tmp29_;
			gchar* link_key = NULL;
			_tmp29_ = g_strdup (link_key_collection[link_key_it]);
			link_key = _tmp29_;
			{
				GeeHashMultiMap* _tmp30_;
				const gchar* _tmp31_;
				FolksIndividual* _tmp32_;
				_tmp30_ = self->priv->_link_map;
				_tmp31_ = link_key;
				_tmp32_ = individual;
				gee_multi_map_remove ((GeeMultiMap*) _tmp30_, _tmp31_, _tmp32_);
				_g_free0 (link_key);
			}
		}
	}
	remove_keys = (_vala_array_free (remove_keys, remove_keys_length1, (GDestroyNotify) g_free), NULL);
}


static void _folks_individual_aggregator_personas_changed_cb (FolksIndividualAggregator* self, FolksPersonaStore* store, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason) {
	GeeHashSet* _tmp0_;
	GeeHashSet* removed_individuals;
	GeeHashMultiMap* _tmp1_;
	GeeHashMultiMap* individuals_changes;
	GeeHashSet* _tmp2_;
	GeeHashSet* relinked_personas;
	GeeHashMap* _tmp3_;
	GeeHashMap* replaced_individuals;
	FolksIndividual* _tmp4_;
	FolksIndividual* _tmp5_;
	FolksIndividual* user;
	GeeSet* _tmp85_;
	gint _tmp86_;
	gint _tmp87_;
	GeeHashSet* _tmp106_;
	FolksIndividual* _tmp142_;
	GeeHashMultiMap* _tmp143_;
	gint _tmp144_;
	gint _tmp145_;
	GeeHashMap* _tmp187_;
	GeeMapIterator* _tmp188_ = NULL;
	GeeMapIterator* iter;
	FolksDebug* _tmp205_;
	gboolean _tmp206_;
	gboolean _tmp207_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (store != NULL);
	g_return_if_fail (added != NULL);
	g_return_if_fail (removed != NULL);
	_tmp0_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	removed_individuals = _tmp0_;
	_tmp1_ = gee_hash_multi_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL, NULL);
	individuals_changes = _tmp1_;
	_tmp2_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	relinked_personas = _tmp2_;
	_tmp3_ = gee_hash_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL);
	replaced_individuals = _tmp3_;
	_tmp4_ = self->priv->_user;
	_tmp5_ = _g_object_ref0 (_tmp4_);
	user = _tmp5_;
	g_debug ("individual-aggregator.vala:1361: Removing Personas:");
	{
		GeeSet* _tmp6_;
		GeeIterator* _tmp7_ = NULL;
		GeeIterator* _persona_it;
		_tmp6_ = removed;
		_tmp7_ = gee_iterable_iterator ((GeeIterable*) _tmp6_);
		_persona_it = _tmp7_;
		while (TRUE) {
			GeeIterator* _tmp8_;
			gboolean _tmp9_ = FALSE;
			GeeIterator* _tmp10_;
			gpointer _tmp11_ = NULL;
			FolksPersona* persona;
			const gchar* _tmp12_ = NULL;
			FolksPersona* _tmp13_;
			gboolean _tmp14_;
			gboolean _tmp15_;
			FolksPersona* _tmp16_;
			const gchar* _tmp17_;
			const gchar* _tmp18_;
			const gchar* _tmp19_;
			FolksPersona* _tmp20_;
			const gchar* _tmp21_;
			const gchar* _tmp22_;
			FolksPersona* _tmp23_;
			FolksIndividual* _tmp24_;
			FolksIndividual* _tmp25_;
			FolksIndividual* _tmp26_;
			FolksIndividual* ind;
			FolksIndividual* _tmp27_;
			FolksPersona* _tmp30_;
			_tmp8_ = _persona_it;
			_tmp9_ = gee_iterator_next (_tmp8_);
			if (!_tmp9_) {
				break;
			}
			_tmp10_ = _persona_it;
			_tmp11_ = gee_iterator_get (_tmp10_);
			persona = (FolksPersona*) _tmp11_;
			_tmp13_ = persona;
			_tmp14_ = folks_persona_get_is_user (_tmp13_);
			_tmp15_ = _tmp14_;
			if (_tmp15_) {
				_tmp12_ = "yes";
			} else {
				_tmp12_ = "no";
			}
			_tmp16_ = persona;
			_tmp17_ = folks_persona_get_uid (_tmp16_);
			_tmp18_ = _tmp17_;
			_tmp19_ = _tmp12_;
			_tmp20_ = persona;
			_tmp21_ = folks_persona_get_iid (_tmp20_);
			_tmp22_ = _tmp21_;
			g_debug ("individual-aggregator.vala:1365:     %s (is user: %s, IID: %s)", _tmp18_, _tmp19_, _tmp22_);
			_tmp23_ = persona;
			_tmp24_ = folks_persona_get_individual (_tmp23_);
			_tmp25_ = _tmp24_;
			_tmp26_ = _g_object_ref0 (_tmp25_);
			ind = _tmp26_;
			_tmp27_ = ind;
			if (_tmp27_ != NULL) {
				GeeHashSet* _tmp28_;
				FolksIndividual* _tmp29_;
				_tmp28_ = removed_individuals;
				_tmp29_ = ind;
				gee_abstract_collection_add ((GeeAbstractCollection*) _tmp28_, G_TYPE_CHECK_INSTANCE_CAST (_tmp29_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
			}
			_tmp30_ = persona;
			_folks_individual_aggregator_disconnect_from_persona (self, _tmp30_);
			_g_object_unref0 (ind);
			_g_object_unref0 (persona);
		}
		_g_object_unref0 (_persona_it);
	}
	g_debug ("individual-aggregator.vala:1389: Removing Individuals due to removed l" \
"inks:");
	{
		GeeHashSet* _tmp31_;
		GeeIterator* _tmp32_ = NULL;
		GeeIterator* _individual_it;
		_tmp31_ = removed_individuals;
		_tmp32_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp31_);
		_individual_it = _tmp32_;
		while (TRUE) {
			GeeIterator* _tmp33_;
			gboolean _tmp34_ = FALSE;
			GeeIterator* _tmp35_;
			gpointer _tmp36_ = NULL;
			FolksIndividual* individual;
			GeeMap* _tmp37_;
			FolksIndividual* _tmp38_;
			const gchar* _tmp39_;
			const gchar* _tmp40_;
			gboolean _tmp41_ = FALSE;
			FolksIndividual* _tmp42_;
			const gchar* _tmp43_;
			const gchar* _tmp44_;
			FolksIndividual* _tmp63_;
			FolksIndividual* _tmp64_;
			FolksIndividual* _tmp65_;
			FolksIndividual* _tmp66_;
			_tmp33_ = _individual_it;
			_tmp34_ = gee_iterator_next (_tmp33_);
			if (!_tmp34_) {
				break;
			}
			_tmp35_ = _individual_it;
			_tmp36_ = gee_iterator_get (_tmp35_);
			individual = (FolksIndividual*) _tmp36_;
			_tmp37_ = self->priv->_individuals;
			_tmp38_ = individual;
			_tmp39_ = folks_individual_get_id (_tmp38_);
			_tmp40_ = _tmp39_;
			_tmp41_ = gee_map_has_key (_tmp37_, _tmp40_);
			if (_tmp41_ == FALSE) {
				_g_object_unref0 (individual);
				continue;
			}
			_tmp42_ = individual;
			_tmp43_ = folks_individual_get_id (_tmp42_);
			_tmp44_ = _tmp43_;
			g_debug ("individual-aggregator.vala:1396:     %s", _tmp44_);
			{
				FolksIndividual* _tmp45_;
				GeeSet* _tmp46_;
				GeeSet* _tmp47_;
				GeeIterator* _tmp48_ = NULL;
				GeeIterator* _persona_it;
				_tmp45_ = individual;
				_tmp46_ = folks_individual_get_personas (_tmp45_);
				_tmp47_ = _tmp46_;
				_tmp48_ = gee_iterable_iterator ((GeeIterable*) _tmp47_);
				_persona_it = _tmp48_;
				while (TRUE) {
					GeeIterator* _tmp49_;
					gboolean _tmp50_ = FALSE;
					GeeIterator* _tmp51_;
					gpointer _tmp52_ = NULL;
					FolksPersona* persona;
					gboolean _tmp53_ = FALSE;
					GeeSet* _tmp54_;
					FolksPersona* _tmp55_;
					gboolean _tmp56_ = FALSE;
					gboolean _tmp60_;
					GeeHashSet* _tmp61_;
					FolksPersona* _tmp62_;
					_tmp49_ = _persona_it;
					_tmp50_ = gee_iterator_next (_tmp49_);
					if (!_tmp50_) {
						break;
					}
					_tmp51_ = _persona_it;
					_tmp52_ = gee_iterator_get (_tmp51_);
					persona = (FolksPersona*) _tmp52_;
					_tmp54_ = removed;
					_tmp55_ = persona;
					_tmp56_ = gee_collection_contains ((GeeCollection*) _tmp54_, _tmp55_);
					if (_tmp56_ == TRUE) {
						_tmp53_ = TRUE;
					} else {
						GeeHashSet* _tmp57_;
						FolksPersona* _tmp58_;
						gboolean _tmp59_ = FALSE;
						_tmp57_ = relinked_personas;
						_tmp58_ = persona;
						_tmp59_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _tmp57_, _tmp58_);
						_tmp53_ = _tmp59_ == TRUE;
					}
					_tmp60_ = _tmp53_;
					if (_tmp60_) {
						_g_object_unref0 (persona);
						continue;
					}
					_tmp61_ = relinked_personas;
					_tmp62_ = persona;
					gee_abstract_collection_add ((GeeAbstractCollection*) _tmp61_, _tmp62_);
					_g_object_unref0 (persona);
				}
				_g_object_unref0 (_persona_it);
			}
			_tmp63_ = user;
			_tmp64_ = individual;
			if (_tmp63_ == _tmp64_) {
				_g_object_unref0 (user);
				user = NULL;
			}
			_tmp65_ = individual;
			_folks_individual_aggregator_disconnect_from_individual (self, _tmp65_);
			_tmp66_ = individual;
			_folks_individual_aggregator_remove_individual_from_link_map (self, _tmp66_);
			_g_object_unref0 (individual);
		}
		_g_object_unref0 (_individual_it);
	}
	g_debug ("individual-aggregator.vala:1418: Adding Personas:");
	{
		GeeSet* _tmp67_;
		GeeIterator* _tmp68_ = NULL;
		GeeIterator* _persona_it;
		_tmp67_ = added;
		_tmp68_ = gee_iterable_iterator ((GeeIterable*) _tmp67_);
		_persona_it = _tmp68_;
		while (TRUE) {
			GeeIterator* _tmp69_;
			gboolean _tmp70_ = FALSE;
			GeeIterator* _tmp71_;
			gpointer _tmp72_ = NULL;
			FolksPersona* persona;
			const gchar* _tmp73_ = NULL;
			FolksPersona* _tmp74_;
			gboolean _tmp75_;
			gboolean _tmp76_;
			FolksPersona* _tmp77_;
			const gchar* _tmp78_;
			const gchar* _tmp79_;
			const gchar* _tmp80_;
			FolksPersona* _tmp81_;
			const gchar* _tmp82_;
			const gchar* _tmp83_;
			FolksPersona* _tmp84_;
			_tmp69_ = _persona_it;
			_tmp70_ = gee_iterator_next (_tmp69_);
			if (!_tmp70_) {
				break;
			}
			_tmp71_ = _persona_it;
			_tmp72_ = gee_iterator_get (_tmp71_);
			persona = (FolksPersona*) _tmp72_;
			_tmp74_ = persona;
			_tmp75_ = folks_persona_get_is_user (_tmp74_);
			_tmp76_ = _tmp75_;
			if (_tmp76_) {
				_tmp73_ = "yes";
			} else {
				_tmp73_ = "no";
			}
			_tmp77_ = persona;
			_tmp78_ = folks_persona_get_uid (_tmp77_);
			_tmp79_ = _tmp78_;
			_tmp80_ = _tmp73_;
			_tmp81_ = persona;
			_tmp82_ = folks_persona_get_iid (_tmp81_);
			_tmp83_ = _tmp82_;
			g_debug ("individual-aggregator.vala:1421:     %s (is user: %s, IID: %s)", _tmp79_, _tmp80_, _tmp83_);
			_tmp84_ = persona;
			_folks_individual_aggregator_connect_to_persona (self, _tmp84_);
			_g_object_unref0 (persona);
		}
		_g_object_unref0 (_persona_it);
	}
	_tmp85_ = added;
	_tmp86_ = gee_collection_get_size ((GeeCollection*) _tmp85_);
	_tmp87_ = _tmp86_;
	if (_tmp87_ > 0) {
		GeeSet* _tmp88_;
		_tmp88_ = added;
		_folks_individual_aggregator_add_personas (self, _tmp88_, &user, &individuals_changes);
	}
	g_debug ("individual-aggregator.vala:1434: Relinking Personas:");
	{
		GeeHashSet* _tmp89_;
		GeeIterator* _tmp90_ = NULL;
		GeeIterator* _persona_it;
		_tmp89_ = relinked_personas;
		_tmp90_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp89_);
		_persona_it = _tmp90_;
		while (TRUE) {
			GeeIterator* _tmp91_;
			gboolean _tmp92_ = FALSE;
			GeeIterator* _tmp93_;
			gpointer _tmp94_ = NULL;
			FolksPersona* persona;
			const gchar* _tmp95_ = NULL;
			FolksPersona* _tmp96_;
			gboolean _tmp97_;
			gboolean _tmp98_;
			FolksPersona* _tmp99_;
			const gchar* _tmp100_;
			const gchar* _tmp101_;
			const gchar* _tmp102_;
			FolksPersona* _tmp103_;
			const gchar* _tmp104_;
			const gchar* _tmp105_;
			_tmp91_ = _persona_it;
			_tmp92_ = gee_iterator_next (_tmp91_);
			if (!_tmp92_) {
				break;
			}
			_tmp93_ = _persona_it;
			_tmp94_ = gee_iterator_get (_tmp93_);
			persona = (FolksPersona*) _tmp94_;
			_tmp96_ = persona;
			_tmp97_ = folks_persona_get_is_user (_tmp96_);
			_tmp98_ = _tmp97_;
			if (_tmp98_) {
				_tmp95_ = "yes";
			} else {
				_tmp95_ = "no";
			}
			_tmp99_ = persona;
			_tmp100_ = folks_persona_get_uid (_tmp99_);
			_tmp101_ = _tmp100_;
			_tmp102_ = _tmp95_;
			_tmp103_ = persona;
			_tmp104_ = folks_persona_get_iid (_tmp103_);
			_tmp105_ = _tmp104_;
			g_debug ("individual-aggregator.vala:1437:     %s (is user: %s, IID: %s)", _tmp101_, _tmp102_, _tmp105_);
			_g_object_unref0 (persona);
		}
		_g_object_unref0 (_persona_it);
	}
	_tmp106_ = relinked_personas;
	_folks_individual_aggregator_add_personas (self, (GeeSet*) _tmp106_, &user, &individuals_changes);
	{
		GeeHashSet* _tmp107_;
		GeeIterator* _tmp108_ = NULL;
		GeeIterator* _individual_it;
		_tmp107_ = removed_individuals;
		_tmp108_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp107_);
		_individual_it = _tmp108_;
		while (TRUE) {
			GeeIterator* _tmp109_;
			gboolean _tmp110_ = FALSE;
			GeeIterator* _tmp111_;
			gpointer _tmp112_ = NULL;
			FolksIndividual* individual;
			gboolean added_mapping;
			gboolean _tmp138_;
			FolksIndividual* _tmp141_;
			_tmp109_ = _individual_it;
			_tmp110_ = gee_iterator_next (_tmp109_);
			if (!_tmp110_) {
				break;
			}
			_tmp111_ = _individual_it;
			_tmp112_ = gee_iterator_get (_tmp111_);
			individual = (FolksIndividual*) _tmp112_;
			added_mapping = FALSE;
			{
				FolksIndividual* _tmp113_;
				GeeSet* _tmp114_;
				GeeSet* _tmp115_;
				GeeIterator* _tmp116_ = NULL;
				GeeIterator* _persona_it;
				_tmp113_ = individual;
				_tmp114_ = folks_individual_get_personas (_tmp113_);
				_tmp115_ = _tmp114_;
				_tmp116_ = gee_iterable_iterator ((GeeIterable*) _tmp115_);
				_persona_it = _tmp116_;
				while (TRUE) {
					GeeIterator* _tmp117_;
					gboolean _tmp118_ = FALSE;
					GeeIterator* _tmp119_;
					gpointer _tmp120_ = NULL;
					FolksPersona* persona;
					gboolean _tmp121_ = FALSE;
					GeeSet* _tmp122_;
					FolksPersona* _tmp123_;
					gboolean _tmp124_ = FALSE;
					gboolean _tmp128_;
					_tmp117_ = _persona_it;
					_tmp118_ = gee_iterator_next (_tmp117_);
					if (!_tmp118_) {
						break;
					}
					_tmp119_ = _persona_it;
					_tmp120_ = gee_iterator_get (_tmp119_);
					persona = (FolksPersona*) _tmp120_;
					_tmp122_ = removed;
					_tmp123_ = persona;
					_tmp124_ = gee_collection_contains ((GeeCollection*) _tmp122_, _tmp123_);
					if (!_tmp124_) {
						_tmp121_ = TRUE;
					} else {
						GeeSet* _tmp125_;
						FolksPersona* _tmp126_;
						gboolean _tmp127_ = FALSE;
						_tmp125_ = added;
						_tmp126_ = persona;
						_tmp127_ = gee_collection_contains ((GeeCollection*) _tmp125_, _tmp126_);
						_tmp121_ = _tmp127_;
					}
					_tmp128_ = _tmp121_;
					if (_tmp128_) {
						GeeHashMultiMap* _tmp129_;
						FolksPersona* _tmp130_;
						FolksIndividual* _tmp131_;
						FolksIndividual* _tmp132_;
						GeeHashMultiMap* _tmp133_;
						FolksIndividual* _tmp134_;
						FolksPersona* _tmp135_;
						FolksIndividual* _tmp136_;
						FolksIndividual* _tmp137_;
						_tmp129_ = individuals_changes;
						_tmp130_ = persona;
						_tmp131_ = folks_persona_get_individual (_tmp130_);
						_tmp132_ = _tmp131_;
						gee_multi_map_remove ((GeeMultiMap*) _tmp129_, NULL, _tmp132_);
						_tmp133_ = individuals_changes;
						_tmp134_ = individual;
						_tmp135_ = persona;
						_tmp136_ = folks_persona_get_individual (_tmp135_);
						_tmp137_ = _tmp136_;
						gee_multi_map_set ((GeeMultiMap*) _tmp133_, _tmp134_, _tmp137_);
						added_mapping = TRUE;
					}
					_g_object_unref0 (persona);
				}
				_g_object_unref0 (_persona_it);
			}
			_tmp138_ = added_mapping;
			if (_tmp138_ == FALSE) {
				GeeHashMultiMap* _tmp139_;
				FolksIndividual* _tmp140_;
				_tmp139_ = individuals_changes;
				_tmp140_ = individual;
				gee_multi_map_set ((GeeMultiMap*) _tmp139_, _tmp140_, NULL);
			}
			_tmp141_ = individual;
			folks_individual_set_personas (_tmp141_, NULL);
			_g_object_unref0 (individual);
		}
		_g_object_unref0 (_individual_it);
	}
	_tmp142_ = user;
	folks_individual_aggregator_set_user (self, _tmp142_);
	_tmp143_ = individuals_changes;
	_tmp144_ = gee_multi_map_get_size ((GeeMultiMap*) _tmp143_);
	_tmp145_ = _tmp144_;
	if (_tmp145_ > 0) {
		GeeHashSet* _tmp146_;
		GeeHashSet* added_individuals;
		GeeHashSet* _tmp184_;
		GeeHashSet* _tmp185_;
		GeeHashMultiMap* _tmp186_;
		_tmp146_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
		added_individuals = _tmp146_;
		{
			GeeHashMultiMap* _tmp147_;
			GeeSet* _tmp148_ = NULL;
			GeeSet* _tmp149_;
			GeeIterator* _tmp150_ = NULL;
			GeeIterator* _tmp151_;
			GeeIterator* _old_ind_it;
			_tmp147_ = individuals_changes;
			_tmp148_ = gee_multi_map_get_keys ((GeeMultiMap*) _tmp147_);
			_tmp149_ = _tmp148_;
			_tmp150_ = gee_iterable_iterator ((GeeIterable*) _tmp149_);
			_tmp151_ = _tmp150_;
			_g_object_unref0 (_tmp149_);
			_old_ind_it = _tmp151_;
			while (TRUE) {
				GeeIterator* _tmp152_;
				gboolean _tmp153_ = FALSE;
				GeeIterator* _tmp154_;
				gpointer _tmp155_ = NULL;
				FolksIndividual* old_ind;
				_tmp152_ = _old_ind_it;
				_tmp153_ = gee_iterator_next (_tmp152_);
				if (!_tmp153_) {
					break;
				}
				_tmp154_ = _old_ind_it;
				_tmp155_ = gee_iterator_get (_tmp154_);
				old_ind = (FolksIndividual*) _tmp155_;
				{
					GeeHashMultiMap* _tmp156_;
					FolksIndividual* _tmp157_;
					GeeCollection* _tmp158_ = NULL;
					GeeCollection* _tmp159_;
					GeeIterator* _tmp160_ = NULL;
					GeeIterator* _tmp161_;
					GeeIterator* _new_ind_it;
					_tmp156_ = individuals_changes;
					_tmp157_ = old_ind;
					_tmp158_ = gee_multi_map_get ((GeeMultiMap*) _tmp156_, _tmp157_);
					_tmp159_ = _tmp158_;
					_tmp160_ = gee_iterable_iterator ((GeeIterable*) _tmp159_);
					_tmp161_ = _tmp160_;
					_g_object_unref0 (_tmp159_);
					_new_ind_it = _tmp161_;
					while (TRUE) {
						GeeIterator* _tmp162_;
						gboolean _tmp163_ = FALSE;
						GeeIterator* _tmp164_;
						gpointer _tmp165_ = NULL;
						FolksIndividual* new_ind;
						gboolean _tmp166_ = FALSE;
						FolksIndividual* _tmp167_;
						gboolean _tmp169_;
						FolksIndividual* _tmp170_;
						FolksIndividual* _tmp173_;
						gboolean _tmp177_ = FALSE;
						FolksIndividual* _tmp178_;
						gboolean _tmp180_;
						_tmp162_ = _new_ind_it;
						_tmp163_ = gee_iterator_next (_tmp162_);
						if (!_tmp163_) {
							break;
						}
						_tmp164_ = _new_ind_it;
						_tmp165_ = gee_iterator_get (_tmp164_);
						new_ind = (FolksIndividual*) _tmp165_;
						_tmp167_ = old_ind;
						if (_tmp167_ != NULL) {
							_tmp166_ = TRUE;
						} else {
							FolksIndividual* _tmp168_;
							_tmp168_ = new_ind;
							_tmp166_ = _tmp168_ != NULL;
						}
						_tmp169_ = _tmp166_;
						_vala_assert (_tmp169_, "old_ind != null || new_ind != null");
						_tmp170_ = old_ind;
						if (_tmp170_ != NULL) {
							GeeHashSet* _tmp171_;
							FolksIndividual* _tmp172_;
							_tmp171_ = removed_individuals;
							_tmp172_ = old_ind;
							gee_abstract_collection_add ((GeeAbstractCollection*) _tmp171_, G_TYPE_CHECK_INSTANCE_CAST (_tmp172_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
						}
						_tmp173_ = new_ind;
						if (_tmp173_ != NULL) {
							GeeHashSet* _tmp174_;
							FolksIndividual* _tmp175_;
							FolksIndividual* _tmp176_;
							_tmp174_ = added_individuals;
							_tmp175_ = new_ind;
							gee_abstract_collection_add ((GeeAbstractCollection*) _tmp174_, G_TYPE_CHECK_INSTANCE_CAST (_tmp175_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
							_tmp176_ = new_ind;
							_folks_individual_aggregator_connect_to_individual (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp176_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
						}
						_tmp178_ = old_ind;
						if (_tmp178_ != NULL) {
							FolksIndividual* _tmp179_;
							_tmp179_ = new_ind;
							_tmp177_ = _tmp179_ != NULL;
						} else {
							_tmp177_ = FALSE;
						}
						_tmp180_ = _tmp177_;
						if (_tmp180_) {
							GeeHashMap* _tmp181_;
							FolksIndividual* _tmp182_;
							FolksIndividual* _tmp183_;
							_tmp181_ = replaced_individuals;
							_tmp182_ = old_ind;
							_tmp183_ = new_ind;
							gee_abstract_map_set ((GeeAbstractMap*) _tmp181_, G_TYPE_CHECK_INSTANCE_CAST (_tmp182_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), G_TYPE_CHECK_INSTANCE_CAST (_tmp183_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
						}
						_g_object_unref0 (new_ind);
					}
					_g_object_unref0 (_new_ind_it);
				}
				_g_object_unref0 (old_ind);
			}
			_g_object_unref0 (_old_ind_it);
		}
		_tmp184_ = added_individuals;
		_tmp185_ = removed_individuals;
		_tmp186_ = individuals_changes;
		_folks_individual_aggregator_emit_individuals_changed (self, (GeeSet*) _tmp184_, (GeeSet*) _tmp185_, (GeeMultiMap*) _tmp186_, NULL, NULL, FOLKS_GROUP_DETAILS_CHANGE_REASON_NONE);
		_g_object_unref0 (added_individuals);
	}
	g_debug ("individual-aggregator.vala:1510: Replacing Individuals due to linking:");
	_tmp187_ = replaced_individuals;
	_tmp188_ = gee_abstract_map_map_iterator ((GeeAbstractMap*) _tmp187_);
	iter = _tmp188_;
	while (TRUE) {
		GeeMapIterator* _tmp189_;
		gboolean _tmp190_ = FALSE;
		GeeMapIterator* _tmp191_;
		gpointer _tmp192_ = NULL;
		FolksIndividual* old_ind;
		GeeMapIterator* _tmp193_;
		gpointer _tmp194_ = NULL;
		FolksIndividual* new_ind;
		FolksIndividual* _tmp195_;
		const gchar* _tmp196_;
		const gchar* _tmp197_;
		FolksIndividual* _tmp198_;
		FolksIndividual* _tmp199_;
		const gchar* _tmp200_;
		const gchar* _tmp201_;
		FolksIndividual* _tmp202_;
		FolksIndividual* _tmp203_;
		FolksIndividual* _tmp204_;
		_tmp189_ = iter;
		_tmp190_ = gee_map_iterator_next (_tmp189_);
		if (!(_tmp190_ == TRUE)) {
			break;
		}
		_tmp191_ = iter;
		_tmp192_ = gee_map_iterator_get_key (_tmp191_);
		old_ind = (FolksIndividual*) _tmp192_;
		_tmp193_ = iter;
		_tmp194_ = gee_map_iterator_get_value (_tmp193_);
		new_ind = (FolksIndividual*) _tmp194_;
		_tmp195_ = old_ind;
		_tmp196_ = folks_individual_get_id (_tmp195_);
		_tmp197_ = _tmp196_;
		_tmp198_ = old_ind;
		_tmp199_ = new_ind;
		_tmp200_ = folks_individual_get_id (_tmp199_);
		_tmp201_ = _tmp200_;
		_tmp202_ = new_ind;
		g_debug ("individual-aggregator.vala:1517:     %s (%p) → %s (%p)", _tmp197_, _tmp198_, _tmp201_, _tmp202_);
		_tmp203_ = old_ind;
		_tmp204_ = new_ind;
		folks_individual_replace (_tmp203_, _tmp204_);
		_g_object_unref0 (new_ind);
		_g_object_unref0 (old_ind);
	}
	_tmp205_ = self->priv->_debug;
	_tmp206_ = folks_debug_get_debug_output_enabled (_tmp205_);
	_tmp207_ = _tmp206_;
	if (_tmp207_ == TRUE) {
		{
			GeeHashMultiMap* _tmp208_;
			GeeSet* _tmp209_ = NULL;
			GeeSet* _tmp210_;
			GeeIterator* _tmp211_ = NULL;
			GeeIterator* _tmp212_;
			GeeIterator* _link_key_it;
			_tmp208_ = self->priv->_link_map;
			_tmp209_ = gee_multi_map_get_keys ((GeeMultiMap*) _tmp208_);
			_tmp210_ = _tmp209_;
			_tmp211_ = gee_iterable_iterator ((GeeIterable*) _tmp210_);
			_tmp212_ = _tmp211_;
			_g_object_unref0 (_tmp210_);
			_link_key_it = _tmp212_;
			while (TRUE) {
				GeeIterator* _tmp213_;
				gboolean _tmp214_ = FALSE;
				GeeIterator* _tmp215_;
				gpointer _tmp216_ = NULL;
				gchar* link_key;
				_tmp213_ = _link_key_it;
				_tmp214_ = gee_iterator_next (_tmp213_);
				if (!_tmp214_) {
					break;
				}
				_tmp215_ = _link_key_it;
				_tmp216_ = gee_iterator_get (_tmp215_);
				link_key = (gchar*) _tmp216_;
				{
					GeeHashMultiMap* _tmp217_;
					const gchar* _tmp218_;
					GeeCollection* _tmp219_ = NULL;
					GeeCollection* _tmp220_;
					GeeIterator* _tmp221_ = NULL;
					GeeIterator* _tmp222_;
					GeeIterator* _individual_it;
					_tmp217_ = self->priv->_link_map;
					_tmp218_ = link_key;
					_tmp219_ = gee_multi_map_get ((GeeMultiMap*) _tmp217_, _tmp218_);
					_tmp220_ = _tmp219_;
					_tmp221_ = gee_iterable_iterator ((GeeIterable*) _tmp220_);
					_tmp222_ = _tmp221_;
					_g_object_unref0 (_tmp220_);
					_individual_it = _tmp222_;
					while (TRUE) {
						GeeIterator* _tmp223_;
						gboolean _tmp224_ = FALSE;
						GeeIterator* _tmp225_;
						gpointer _tmp226_ = NULL;
						FolksIndividual* individual;
						GeeMap* _tmp227_;
						FolksIndividual* _tmp228_;
						const gchar* _tmp229_;
						const gchar* _tmp230_;
						gpointer _tmp231_ = NULL;
						FolksIndividual* _tmp232_;
						FolksIndividual* _tmp233_;
						gboolean _tmp234_;
						_tmp223_ = _individual_it;
						_tmp224_ = gee_iterator_next (_tmp223_);
						if (!_tmp224_) {
							break;
						}
						_tmp225_ = _individual_it;
						_tmp226_ = gee_iterator_get (_tmp225_);
						individual = (FolksIndividual*) _tmp226_;
						_tmp227_ = self->priv->_individuals;
						_tmp228_ = individual;
						_tmp229_ = folks_individual_get_id (_tmp228_);
						_tmp230_ = _tmp229_;
						_tmp231_ = gee_map_get (_tmp227_, _tmp230_);
						_tmp232_ = (FolksIndividual*) _tmp231_;
						_tmp233_ = individual;
						_tmp234_ = _tmp232_ != _tmp233_;
						_g_object_unref0 (_tmp232_);
						if (_tmp234_) {
							const gchar* _tmp235_;
							FolksIndividual* _tmp236_;
							const gchar* _tmp237_;
							const gchar* _tmp238_;
							FolksIndividual* _tmp239_;
							FolksIndividual* _tmp240_;
							const gchar* _tmp241_;
							const gchar* _tmp242_;
							FolksIndividual* _tmp243_;
							_tmp235_ = link_key;
							_tmp236_ = individual;
							_tmp237_ = folks_individual_get_id (_tmp236_);
							_tmp238_ = _tmp237_;
							_tmp239_ = individual;
							g_warning ("Link map contains invalid mapping:\n" "    %s → %s (%p)", _tmp235_, _tmp238_, _tmp239_);
							_tmp240_ = individual;
							_tmp241_ = folks_individual_get_id (_tmp240_);
							_tmp242_ = _tmp241_;
							_tmp243_ = individual;
							g_warning ("individual-aggregator.vala:1535: Individual %s (%p) personas:", _tmp242_, _tmp243_);
							{
								FolksIndividual* _tmp244_;
								GeeSet* _tmp245_;
								GeeSet* _tmp246_;
								GeeIterator* _tmp247_ = NULL;
								GeeIterator* _p_it;
								_tmp244_ = individual;
								_tmp245_ = folks_individual_get_personas (_tmp244_);
								_tmp246_ = _tmp245_;
								_tmp247_ = gee_iterable_iterator ((GeeIterable*) _tmp246_);
								_p_it = _tmp247_;
								while (TRUE) {
									GeeIterator* _tmp248_;
									gboolean _tmp249_ = FALSE;
									GeeIterator* _tmp250_;
									gpointer _tmp251_ = NULL;
									FolksPersona* p;
									FolksPersona* _tmp252_;
									const gchar* _tmp253_;
									const gchar* _tmp254_;
									FolksPersona* _tmp255_;
									_tmp248_ = _p_it;
									_tmp249_ = gee_iterator_next (_tmp248_);
									if (!_tmp249_) {
										break;
									}
									_tmp250_ = _p_it;
									_tmp251_ = gee_iterator_get (_tmp250_);
									p = (FolksPersona*) _tmp251_;
									_tmp252_ = p;
									_tmp253_ = folks_persona_get_uid (_tmp252_);
									_tmp254_ = _tmp253_;
									_tmp255_ = p;
									g_warning ("individual-aggregator.vala:1539:     %s (%p)", _tmp254_, _tmp255_);
									_g_object_unref0 (p);
								}
								_g_object_unref0 (_p_it);
							}
						}
						_g_object_unref0 (individual);
					}
					_g_object_unref0 (_individual_it);
				}
				_g_free0 (link_key);
			}
			_g_object_unref0 (_link_key_it);
		}
	}
	_g_object_unref0 (iter);
	_g_object_unref0 (user);
	_g_object_unref0 (replaced_individuals);
	_g_object_unref0 (relinked_personas);
	_g_object_unref0 (individuals_changes);
	_g_object_unref0 (removed_individuals);
}


static void _folks_individual_aggregator_is_primary_store_changed_cb (FolksIndividualAggregator* self, GObject* object, GParamSpec* pspec) {
	GObject* _tmp0_;
	FolksPersonaStore* _tmp1_;
	FolksPersonaStore* store;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp3_ = FALSE;
	FolksPersonaStore* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	gboolean _tmp9_;
	gboolean _tmp17_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (object != NULL);
	g_return_if_fail (pspec != NULL);
	_tmp0_ = object;
	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore));
	store = _tmp1_;
	_tmp4_ = store;
	_tmp5_ = folks_persona_store_get_is_primary_store (_tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ == TRUE) {
		FolksPersonaStore* _tmp7_;
		FolksPersonaStore* _tmp8_;
		_tmp7_ = store;
		_tmp8_ = self->priv->_primary_store;
		_tmp3_ = _tmp7_ == _tmp8_;
	} else {
		_tmp3_ = FALSE;
	}
	_tmp9_ = _tmp3_;
	if (_tmp9_) {
		_tmp2_ = TRUE;
	} else {
		gboolean _tmp10_ = FALSE;
		FolksPersonaStore* _tmp11_;
		gboolean _tmp12_;
		gboolean _tmp13_;
		gboolean _tmp16_;
		_tmp11_ = store;
		_tmp12_ = folks_persona_store_get_is_primary_store (_tmp11_);
		_tmp13_ = _tmp12_;
		if (_tmp13_ == FALSE) {
			FolksPersonaStore* _tmp14_;
			FolksPersonaStore* _tmp15_;
			_tmp14_ = store;
			_tmp15_ = self->priv->_primary_store;
			_tmp10_ = _tmp14_ != _tmp15_;
		} else {
			_tmp10_ = FALSE;
		}
		_tmp16_ = _tmp10_;
		_tmp2_ = _tmp16_;
	}
	_tmp17_ = _tmp2_;
	_vala_assert (_tmp17_, "(store.is_primary_store == true &&               store == this._primary_store) ||           (store.is_primary_store == false &&               store != this._primary_store)");
	_g_object_unref0 (store);
}


static void _folks_individual_aggregator_persona_store_is_quiescent_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec) {
	guint _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (obj != NULL);
	g_return_if_fail (pspec != NULL);
	_tmp0_ = self->priv->_non_quiescent_persona_store_count;
	if (_tmp0_ > ((guint) 0)) {
		guint _tmp1_;
		_tmp1_ = self->priv->_non_quiescent_persona_store_count;
		self->priv->_non_quiescent_persona_store_count = _tmp1_ - 1;
		_folks_individual_aggregator_notify_if_is_quiescent (self);
	}
}


static void _folks_individual_aggregator_backend_is_quiescent_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec) {
	guint _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (obj != NULL);
	g_return_if_fail (pspec != NULL);
	_tmp0_ = self->priv->_non_quiescent_backend_count;
	if (_tmp0_ > ((guint) 0)) {
		guint _tmp1_;
		_tmp1_ = self->priv->_non_quiescent_backend_count;
		self->priv->_non_quiescent_backend_count = _tmp1_ - 1;
		_folks_individual_aggregator_notify_if_is_quiescent (self);
	}
}


static void _folks_individual_aggregator_notify_if_is_quiescent (FolksIndividualAggregator* self) {
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	guint _tmp2_;
	gboolean _tmp4_;
	gboolean _tmp6_;
	g_return_if_fail (self != NULL);
	_tmp2_ = self->priv->_non_quiescent_backend_count;
	if (_tmp2_ == ((guint) 0)) {
		guint _tmp3_;
		_tmp3_ = self->priv->_non_quiescent_persona_store_count;
		_tmp1_ = _tmp3_ == ((guint) 0);
	} else {
		_tmp1_ = FALSE;
	}
	_tmp4_ = _tmp1_;
	if (_tmp4_) {
		gboolean _tmp5_;
		_tmp5_ = self->priv->_is_quiescent;
		_tmp0_ = _tmp5_ == FALSE;
	} else {
		_tmp0_ = FALSE;
	}
	_tmp6_ = _tmp0_;
	if (_tmp6_) {
		gboolean _tmp7_ = FALSE;
		const gchar* _tmp8_;
		gint _tmp9_;
		gint _tmp10_;
		gboolean _tmp12_;
		guint _tmp15_;
		_tmp8_ = self->priv->_configured_primary_store_type_id;
		_tmp9_ = strlen (_tmp8_);
		_tmp10_ = _tmp9_;
		if (_tmp10_ > 0) {
			FolksPersonaStore* _tmp11_;
			_tmp11_ = self->priv->_primary_store;
			_tmp7_ = _tmp11_ == NULL;
		} else {
			_tmp7_ = FALSE;
		}
		_tmp12_ = _tmp7_;
		if (_tmp12_) {
			const gchar* _tmp13_;
			const gchar* _tmp14_;
			_tmp13_ = self->priv->_configured_primary_store_type_id;
			_tmp14_ = self->priv->_configured_primary_store_id;
			g_warning ("Failed to find primary PersonaStore with type ID " "'%s' and ID '%s'.\n" "Individuals will not be linked properly " "and creating new links between Personas will not work.\n" "The configured primary PersonaStore's backend may not be " "installed. If you are unsure, check with your " "distribution.", _tmp13_, _tmp14_);
		}
		folks_internal_profiling_point ("reached quiescence in " "IndividualAggregator", NULL);
		self->priv->_is_quiescent = TRUE;
		g_object_notify ((GObject*) self, "is-quiescent");
		_tmp15_ = self->priv->_quiescent_timeout_id;
		if (_tmp15_ != ((guint) 0)) {
			guint _tmp16_;
			_tmp16_ = self->priv->_quiescent_timeout_id;
			g_source_remove (_tmp16_);
			self->priv->_quiescent_timeout_id = (guint) 0;
		}
	}
}


static gboolean _folks_individual_aggregator_quiescent_timeout_cb (FolksIndividualAggregator* self) {
	gboolean result = FALSE;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_is_quiescent;
	if (_tmp0_ == FALSE) {
		guint _tmp1_;
		guint _tmp2_;
		_tmp1_ = self->priv->_non_quiescent_backend_count;
		_tmp2_ = self->priv->_non_quiescent_persona_store_count;
		g_warning ("Failed to reach quiescence normally (%u backends and %u " "persona stores still haven't reached quiescence). Forcing " "IndividualAggregator quiescence due to reaching the timeout.", _tmp1_, _tmp2_);
		self->priv->_is_quiescent = TRUE;
		g_object_notify ((GObject*) self, "is-quiescent");
	}
	self->priv->_quiescent_timeout_id = (guint) 0;
	result = FALSE;
	return result;
}


static void _folks_individual_aggregator_persona_store_is_user_set_default_changed_cb (FolksIndividualAggregator* self, GObject* obj, GParamSpec* pspec) {
	GObject* _tmp0_;
	FolksPersonaStore* _tmp1_;
	FolksPersonaStore* store;
	FolksPersonaStore* _tmp2_;
	FolksPersonaStore* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	FolksPersonaStore* _tmp6_;
	const gchar* _tmp7_;
	const gchar* _tmp8_;
	FolksPersonaStore* _tmp9_;
	gboolean _tmp10_ = FALSE;
	g_return_if_fail (self != NULL);
	g_return_if_fail (obj != NULL);
	g_return_if_fail (pspec != NULL);
	_tmp0_ = obj;
	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore));
	store = _tmp1_;
	_tmp2_ = store;
	_tmp3_ = store;
	_tmp4_ = folks_persona_store_get_type_id (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = store;
	_tmp7_ = folks_persona_store_get_id (_tmp6_);
	_tmp8_ = _tmp7_;
	g_debug ("PersonaStore.is-user-set-default changed for store %p " "(type ID: %s, ID: %s)", _tmp2_, _tmp5_, _tmp8_);
	_tmp9_ = store;
	_tmp10_ = _folks_individual_aggregator_maybe_configure_as_primary (self, _tmp9_);
	if (_tmp10_) {
		FolksPersonaStore* _tmp11_;
		_tmp11_ = store;
		_folks_individual_aggregator_set_primary_store (self, _tmp11_);
	}
	_g_object_unref0 (store);
}


static gboolean _folks_individual_aggregator_maybe_configure_as_primary (FolksIndividualAggregator* self, FolksPersonaStore* store) {
	gboolean result = FALSE;
	gboolean configured;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_;
	gboolean _tmp5_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (store != NULL, FALSE);
	g_debug ("individual-aggregator.vala:1648: _maybe_configure_as_primary()");
	configured = FALSE;
	_tmp1_ = self->priv->_user_configured_primary_store;
	if (!_tmp1_) {
		FolksPersonaStore* _tmp2_;
		gboolean _tmp3_;
		gboolean _tmp4_;
		_tmp2_ = store;
		_tmp3_ = folks_persona_store_get_is_user_set_default (_tmp2_);
		_tmp4_ = _tmp3_;
		_tmp0_ = _tmp4_;
	} else {
		_tmp0_ = FALSE;
	}
	_tmp5_ = _tmp0_;
	if (_tmp5_) {
		FolksPersonaStore* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		FolksPersonaStore* _tmp9_;
		const gchar* _tmp10_;
		const gchar* _tmp11_;
		FolksPersonaStore* _tmp12_;
		const gchar* _tmp13_;
		const gchar* _tmp14_;
		gchar* _tmp15_;
		FolksPersonaStore* _tmp16_;
		const gchar* _tmp17_;
		const gchar* _tmp18_;
		gchar* _tmp19_;
		_tmp6_ = store;
		_tmp7_ = folks_persona_store_get_type_id (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = store;
		_tmp10_ = folks_persona_store_get_id (_tmp9_);
		_tmp11_ = _tmp10_;
		g_debug ("individual-aggregator.vala:1655: Setting primary store IDs to '%s' and" \
" '%s'.", _tmp8_, _tmp11_);
		_tmp12_ = store;
		_tmp13_ = folks_persona_store_get_type_id (_tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = g_strdup (_tmp14_);
		_g_free0 (self->priv->_configured_primary_store_type_id);
		self->priv->_configured_primary_store_type_id = _tmp15_;
		_tmp16_ = store;
		_tmp17_ = folks_persona_store_get_id (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = g_strdup (_tmp18_);
		_g_free0 (self->priv->_configured_primary_store_id);
		self->priv->_configured_primary_store_id = _tmp19_;
		configured = TRUE;
	}
	result = configured;
	return result;
}


static void _folks_individual_aggregator_individual_removed_cb (FolksIndividualAggregator* self, FolksIndividual* i, FolksIndividual* replacement) {
	FolksIndividual* _tmp0_;
	FolksIndividual* _tmp1_;
	GeeMap* _tmp2_;
	FolksIndividual* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	gpointer _tmp6_ = NULL;
	FolksIndividual* _tmp7_;
	FolksIndividual* _tmp8_;
	gboolean _tmp9_;
	FolksIndividual* _tmp10_;
	FolksIndividual* _tmp20_;
	GeeSet* _tmp21_;
	GeeSet* _tmp22_;
	gint _tmp23_;
	gint _tmp24_;
	FolksIndividual* _tmp34_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (i != NULL);
	_tmp0_ = self->priv->_user;
	_tmp1_ = i;
	if (_tmp0_ == _tmp1_) {
		folks_individual_aggregator_set_user (self, NULL);
	}
	_tmp2_ = self->priv->_individuals;
	_tmp3_ = i;
	_tmp4_ = folks_individual_get_id (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = gee_map_get (_tmp2_, _tmp5_);
	_tmp7_ = (FolksIndividual*) _tmp6_;
	_tmp8_ = i;
	_tmp9_ = _tmp7_ != _tmp8_;
	_g_object_unref0 (_tmp7_);
	if (_tmp9_) {
		return;
	}
	_tmp10_ = replacement;
	if (_tmp10_ != NULL) {
		FolksIndividual* _tmp11_;
		const gchar* _tmp12_;
		const gchar* _tmp13_;
		FolksIndividual* _tmp14_;
		const gchar* _tmp15_;
		const gchar* _tmp16_;
		_tmp11_ = i;
		_tmp12_ = folks_individual_get_id (_tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = replacement;
		_tmp15_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
		_tmp16_ = _tmp15_;
		g_debug ("individual-aggregator.vala:1677: Individual '%s' removed (replaced by " \
"'%s')", _tmp13_, _tmp16_);
	} else {
		FolksIndividual* _tmp17_;
		const gchar* _tmp18_;
		const gchar* _tmp19_;
		_tmp17_ = i;
		_tmp18_ = folks_individual_get_id (_tmp17_);
		_tmp19_ = _tmp18_;
		g_debug ("individual-aggregator.vala:1682: Individual '%s' removed (not replaced" \
")", _tmp19_);
	}
	_tmp20_ = i;
	_tmp21_ = folks_individual_get_personas (_tmp20_);
	_tmp22_ = _tmp21_;
	_tmp23_ = gee_collection_get_size ((GeeCollection*) _tmp22_);
	_tmp24_ = _tmp23_;
	if (_tmp24_ > 0) {
		GeeHashMultiMap* _tmp25_;
		GeeHashMultiMap* changes;
		GeeHashSet* _tmp26_;
		GeeHashSet* individuals;
		GeeHashSet* _tmp27_;
		FolksIndividual* _tmp28_;
		GeeHashMultiMap* _tmp29_;
		FolksIndividual* _tmp30_;
		FolksIndividual* _tmp31_;
		GeeHashSet* _tmp32_;
		GeeHashMultiMap* _tmp33_;
		_tmp25_ = gee_hash_multi_map_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL, NULL);
		changes = _tmp25_;
		_tmp26_ = gee_hash_set_new (FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
		individuals = _tmp26_;
		_tmp27_ = individuals;
		_tmp28_ = i;
		gee_abstract_collection_add ((GeeAbstractCollection*) _tmp27_, _tmp28_);
		_tmp29_ = changes;
		_tmp30_ = i;
		_tmp31_ = replacement;
		gee_multi_map_set ((GeeMultiMap*) _tmp29_, _tmp30_, _tmp31_);
		_tmp32_ = individuals;
		_tmp33_ = changes;
		_folks_individual_aggregator_emit_individuals_changed (self, NULL, (GeeSet*) _tmp32_, (GeeMultiMap*) _tmp33_, NULL, NULL, FOLKS_GROUP_DETAILS_CHANGE_REASON_NONE);
		_g_object_unref0 (individuals);
		_g_object_unref0 (changes);
	}
	_tmp34_ = i;
	_folks_individual_aggregator_disconnect_from_individual (self, _tmp34_);
}


static void folks_individual_aggregator_add_persona_from_details_data_free (gpointer _data) {
	FolksIndividualAggregatorAddPersonaFromDetailsData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->parent);
	_g_object_unref0 (_data_->persona_store);
	_g_hash_table_unref0 (_data_->details);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorAddPersonaFromDetailsData, _data_);
}


static gpointer _g_hash_table_ref0 (gpointer self) {
	return self ? g_hash_table_ref (self) : NULL;
}


void folks_individual_aggregator_add_persona_from_details (FolksIndividualAggregator* self, FolksIndividual* parent, FolksPersonaStore* persona_store, GHashTable* details, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorAddPersonaFromDetailsData* _data_;
	FolksIndividualAggregator* _tmp0_;
	FolksIndividual* _tmp1_;
	FolksIndividual* _tmp2_;
	FolksPersonaStore* _tmp3_;
	FolksPersonaStore* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorAddPersonaFromDetailsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_add_persona_from_details);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_add_persona_from_details_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = parent;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->parent);
	_data_->parent = _tmp2_;
	_tmp3_ = persona_store;
	_tmp4_ = _g_object_ref0 (_tmp3_);
	_g_object_unref0 (_data_->persona_store);
	_data_->persona_store = _tmp4_;
	_tmp5_ = details;
	_tmp6_ = _g_hash_table_ref0 (_tmp5_);
	_g_hash_table_unref0 (_data_->details);
	_data_->details = _tmp6_;
	folks_individual_aggregator_add_persona_from_details_co (_data_);
}


FolksPersona* folks_individual_aggregator_add_persona_from_details_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksPersona* result;
	FolksIndividualAggregatorAddPersonaFromDetailsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


/**
   * Add a new persona in the given {@link PersonaStore} based on the
   * ``details`` provided.
   *
   * If the target store is offline, this function will throw
   * {@link IndividualAggregatorError.STORE_OFFLINE}. It's the responsibility of
   * the caller to cache details and re-try this function if it wishes to make
   * offline adds work.
   *
   * The details hash is a backend-specific mapping of key, value strings.
   * Common keys include:
   *
   *  * contact - service-specific contact ID
   *  * message - a user-readable message to pass to the persona being added
   *
   * If a {@link Persona} with the given details already exists in the store, no
   * error will be thrown and this function will return ``null``.
   *
   * @param parent an optional {@link Individual} to add the new {@link Persona}
   * to. This persona will be appended to its ordered list of personas.
   * @param persona_store the {@link PersonaStore} to add the persona to
   * @param details a key-value map of details to use in creating the new
   * {@link Persona}
   * @return the new {@link Persona} or ``null`` if the corresponding
   * {@link Persona} already existed. If non-``null``, the new {@link Persona}
   * will also be added to a new or existing {@link Individual} as necessary.
   * @throws IndividualAggregatorError.STORE_OFFLINE if the persona store was
   * offline
   * @throws IndividualAggregatorError.ADD_FAILED if any other error occurred
   * while adding the persona
   *
   * @since 0.3.5
   */
static void folks_individual_aggregator_add_persona_from_details_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorAddPersonaFromDetailsData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_add_persona_from_details_co (_data_);
}


static gboolean folks_individual_aggregator_add_persona_from_details_co (FolksIndividualAggregatorAddPersonaFromDetailsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->persona = NULL;
	{
		_data_->_tmp0_ = _data_->details;
		_data_->_tmp1_ = NULL;
		_data_->_tmp1_ = _folks_individual_aggregator_asv_copy (_data_->self, _data_->_tmp0_);
		_data_->details_copy = _data_->_tmp1_;
		_data_->_tmp2_ = _data_->persona_store;
		_data_->_tmp3_ = _data_->details_copy;
		_data_->_state_ = 1;
		folks_persona_store_add_persona_from_details (_data_->_tmp2_, _data_->_tmp3_, folks_individual_aggregator_add_persona_from_details_ready, _data_);
		return FALSE;
		_state_1:
		_data_->_tmp4_ = NULL;
		_data_->_tmp4_ = folks_persona_store_add_persona_from_details_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		_data_->_tmp5_ = _data_->_tmp4_;
		if (_data_->_inner_error_ != NULL) {
			_g_hash_table_unref0 (_data_->details_copy);
			if (_data_->_inner_error_->domain == FOLKS_PERSONA_STORE_ERROR) {
				goto __catch18_folks_persona_store_error;
			}
			_g_hash_table_unref0 (_data_->details_copy);
			_g_object_unref0 (_data_->persona);
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
		_g_object_unref0 (_data_->persona);
		_data_->persona = _data_->_tmp5_;
		_g_hash_table_unref0 (_data_->details_copy);
	}
	goto __finally18;
	__catch18_folks_persona_store_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->_tmp6_ = _data_->e;
		if (g_error_matches (_data_->_tmp6_, FOLKS_PERSONA_STORE_ERROR, FOLKS_PERSONA_STORE_ERROR_STORE_OFFLINE)) {
			_data_->_tmp7_ = _data_->e;
			_data_->_tmp8_ = _data_->_tmp7_->message;
			_data_->_tmp9_ = g_error_new_literal (FOLKS_INDIVIDUAL_AGGREGATOR_ERROR, FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_STORE_OFFLINE, _data_->_tmp8_);
			_data_->_inner_error_ = _data_->_tmp9_;
			_g_error_free0 (_data_->e);
			goto __finally18;
		} else {
			_data_->_tmp10_ = _data_->persona_store;
			_data_->_tmp11_ = folks_persona_store_get_type_id (_data_->_tmp10_);
			_data_->_tmp12_ = _data_->_tmp11_;
			_data_->_tmp13_ = _data_->persona_store;
			_data_->_tmp14_ = folks_persona_store_get_id (_data_->_tmp13_);
			_data_->_tmp15_ = _data_->_tmp14_;
			_data_->_tmp16_ = NULL;
			_data_->_tmp16_ = _folks_individual_aggregator_get_store_full_id (_data_->self, _data_->_tmp12_, _data_->_tmp15_);
			_data_->full_id = _data_->_tmp16_;
			_data_->_tmp17_ = NULL;
			_data_->_tmp17_ = _ ("Failed to add contact for persona store ID '%s': %s");
			_data_->_tmp18_ = _data_->full_id;
			_data_->_tmp19_ = _data_->e;
			_data_->_tmp20_ = _data_->_tmp19_->message;
			_data_->_tmp21_ = g_error_new (FOLKS_INDIVIDUAL_AGGREGATOR_ERROR, FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_ADD_FAILED, _data_->_tmp17_, _data_->_tmp18_, _data_->_tmp20_);
			_data_->_inner_error_ = _data_->_tmp21_;
			_g_free0 (_data_->full_id);
			_g_error_free0 (_data_->e);
			goto __finally18;
		}
		_g_error_free0 (_data_->e);
	}
	__finally18:
	if (_data_->_inner_error_ != NULL) {
		if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->persona);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->persona);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp23_ = _data_->parent;
	if (_data_->_tmp23_ != NULL) {
		_data_->_tmp24_ = _data_->persona;
		_data_->_tmp22_ = _data_->_tmp24_ != NULL;
	} else {
		_data_->_tmp22_ = FALSE;
	}
	_data_->_tmp25_ = _data_->_tmp22_;
	if (_data_->_tmp25_) {
		_data_->_tmp26_ = _data_->parent;
		_data_->_tmp27_ = folks_individual_get_personas (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp26_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));
		_data_->_tmp28_ = _data_->_tmp27_;
		_data_->_tmp29_ = _data_->persona;
		gee_collection_add ((GeeCollection*) _data_->_tmp28_, G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp29_, FOLKS_TYPE_PERSONA, FolksPersona));
	}
	_data_->result = _data_->persona;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->persona);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static Block8Data* block8_data_ref (Block8Data* _data8_) {
	g_atomic_int_inc (&_data8_->_ref_count_);
	return _data8_;
}


static void block8_data_unref (void * _userdata_) {
	Block8Data* _data8_;
	_data8_ = (Block8Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data8_->_ref_count_)) {
		FolksIndividualAggregator * self;
		self = _data8_->self;
		_g_hash_table_unref0 (_data8_->retval);
		_g_object_unref0 (self);
		g_slice_free (Block8Data, _data8_);
	}
}


static void _g_free0_ (gpointer var) {
	var = (g_free (var), NULL);
}


static void _vala_GValue_free (GValue* self) {
	g_value_unset (self);
	g_free (self);
}


static void __vala_GValue_free0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (_vala_GValue_free (var), NULL));
}


static GValue* _g_value_dup (GValue* self) {
	return g_boxed_copy (G_TYPE_VALUE, self);
}


static gpointer __g_value_dup0 (gpointer self) {
	return self ? _g_value_dup (self) : NULL;
}


static void __lambda65_ (Block8Data* _data8_, const gchar* k, GValue* v) {
	FolksIndividualAggregator * self;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	GValue* _tmp2_;
	GValue* _tmp3_;
	self = _data8_->self;
	g_return_if_fail (k != NULL);
	_tmp0_ = k;
	_tmp1_ = g_strdup ((const gchar*) _tmp0_);
	_tmp2_ = v;
	_tmp3_ = __g_value_dup0 (_tmp2_);
	g_hash_table_insert (_data8_->retval, _tmp1_, _tmp3_);
}


static void ___lambda65__gh_func (gconstpointer key, gconstpointer value, gpointer self) {
	__lambda65_ (self, key, value);
}


static GHashTable* _folks_individual_aggregator_asv_copy (FolksIndividualAggregator* self, GHashTable* asv) {
	GHashTable* result = NULL;
	Block8Data* _data8_;
	GHashFunc _tmp0_;
	GEqualFunc _tmp1_;
	GHashTable* _tmp2_;
	GHashTable* _tmp3_;
	GHashTable* _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (asv != NULL, NULL);
	_data8_ = g_slice_new0 (Block8Data);
	_data8_->_ref_count_ = 1;
	_data8_->self = g_object_ref (self);
	_tmp0_ = g_str_hash;
	_tmp1_ = g_str_equal;
	_tmp2_ = g_hash_table_new_full (_tmp0_, _tmp1_, _g_free0_, __vala_GValue_free0_);
	_data8_->retval = _tmp2_;
	_tmp3_ = asv;
	g_hash_table_foreach (_tmp3_, ___lambda65__gh_func, _data8_);
	_tmp4_ = _g_hash_table_ref0 (_data8_->retval);
	result = _tmp4_;
	block8_data_unref (_data8_);
	_data8_ = NULL;
	return result;
}


static void folks_individual_aggregator_remove_individual_data_free (gpointer _data) {
	FolksIndividualAggregatorRemoveIndividualData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->individual);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorRemoveIndividualData, _data_);
}


void folks_individual_aggregator_remove_individual (FolksIndividualAggregator* self, FolksIndividual* individual, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorRemoveIndividualData* _data_;
	FolksIndividualAggregator* _tmp0_;
	FolksIndividual* _tmp1_;
	FolksIndividual* _tmp2_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorRemoveIndividualData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_remove_individual);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_remove_individual_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = individual;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->individual);
	_data_->individual = _tmp2_;
	folks_individual_aggregator_remove_individual_co (_data_);
}


void folks_individual_aggregator_remove_individual_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividualAggregatorRemoveIndividualData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


/**
   * Completely remove the individual and all of its personas from their
   * backing stores.
   *
   * @param individual the {@link Individual} to remove
   * @throws GLib.Error if removing the persona failed — this will be passed
   * through from {@link PersonaStore.remove_persona}
   *
   * @since 0.1.11
   */
static void folks_individual_aggregator_remove_individual_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorRemoveIndividualData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_remove_individual_co (_data_);
}


static gboolean folks_individual_aggregator_remove_individual_co (FolksIndividualAggregatorRemoveIndividualData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	_data_->personas = _data_->_tmp0_;
	{
		_data_->_tmp1_ = _data_->individual;
		_data_->_tmp2_ = folks_individual_get_personas (_data_->_tmp1_);
		_data_->_tmp3_ = _data_->_tmp2_;
		_data_->_tmp4_ = NULL;
		_data_->_tmp4_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp3_);
		_data_->_p_it = _data_->_tmp4_;
		while (TRUE) {
			_data_->_tmp5_ = _data_->_p_it;
			_data_->_tmp6_ = FALSE;
			_data_->_tmp6_ = gee_iterator_next (_data_->_tmp5_);
			if (!_data_->_tmp6_) {
				break;
			}
			_data_->_tmp7_ = _data_->_p_it;
			_data_->_tmp8_ = NULL;
			_data_->_tmp8_ = gee_iterator_get (_data_->_tmp7_);
			_data_->p = (FolksPersona*) _data_->_tmp8_;
			_data_->_tmp9_ = _data_->personas;
			_data_->_tmp10_ = _data_->p;
			gee_abstract_collection_add ((GeeAbstractCollection*) _data_->_tmp9_, _data_->_tmp10_);
			_g_object_unref0 (_data_->p);
		}
		_g_object_unref0 (_data_->_p_it);
	}
	{
		_data_->_tmp11_ = _data_->personas;
		_data_->_tmp12_ = NULL;
		_data_->_tmp12_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _data_->_tmp11_);
		_data_->_persona_it = _data_->_tmp12_;
		while (TRUE) {
			_data_->_tmp13_ = _data_->_persona_it;
			_data_->_tmp14_ = FALSE;
			_data_->_tmp14_ = gee_iterator_next (_data_->_tmp13_);
			if (!_data_->_tmp14_) {
				break;
			}
			_data_->_tmp15_ = _data_->_persona_it;
			_data_->_tmp16_ = NULL;
			_data_->_tmp16_ = gee_iterator_get (_data_->_tmp15_);
			_data_->persona = (FolksPersona*) _data_->_tmp16_;
			_data_->_tmp17_ = _data_->persona;
			_data_->_tmp18_ = folks_persona_get_store (_data_->_tmp17_);
			_data_->_tmp19_ = _data_->_tmp18_;
			_data_->_tmp20_ = _data_->persona;
			_data_->_state_ = 1;
			folks_persona_store_remove_persona (_data_->_tmp19_, _data_->_tmp20_, folks_individual_aggregator_remove_individual_ready, _data_);
			return FALSE;
			_state_1:
			folks_persona_store_remove_persona_finish (_data_->_tmp19_, _data_->_res_, &_data_->_inner_error_);
			if (_data_->_inner_error_ != NULL) {
				g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
				g_error_free (_data_->_inner_error_);
				_g_object_unref0 (_data_->persona);
				_g_object_unref0 (_data_->_persona_it);
				_g_object_unref0 (_data_->personas);
				if (_data_->_state_ == 0) {
					g_simple_async_result_complete_in_idle (_data_->_async_result);
				} else {
					g_simple_async_result_complete (_data_->_async_result);
				}
				g_object_unref (_data_->_async_result);
				return FALSE;
			}
			_g_object_unref0 (_data_->persona);
		}
		_g_object_unref0 (_data_->_persona_it);
	}
	_g_object_unref0 (_data_->personas);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void folks_individual_aggregator_remove_persona_data_free (gpointer _data) {
	FolksIndividualAggregatorRemovePersonaData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->persona);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorRemovePersonaData, _data_);
}


void folks_individual_aggregator_remove_persona (FolksIndividualAggregator* self, FolksPersona* persona, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorRemovePersonaData* _data_;
	FolksIndividualAggregator* _tmp0_;
	FolksPersona* _tmp1_;
	FolksPersona* _tmp2_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorRemovePersonaData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_remove_persona);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_remove_persona_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = persona;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->persona);
	_data_->persona = _tmp2_;
	folks_individual_aggregator_remove_persona_co (_data_);
}


void folks_individual_aggregator_remove_persona_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividualAggregatorRemovePersonaData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


/**
   * Completely remove the persona from its backing store.
   *
   * This will leave other personas in the same individual alone.
   *
   * @param persona the {@link Persona} to remove
   * @throws GLib.Error if removing the persona failed — this will be passed
   * through from {@link PersonaStore.remove_persona}
   *
   * @since 0.1.11
   */
static void folks_individual_aggregator_remove_persona_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorRemovePersonaData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_remove_persona_co (_data_);
}


static gboolean folks_individual_aggregator_remove_persona_co (FolksIndividualAggregatorRemovePersonaData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = _data_->persona;
	_data_->_tmp1_ = folks_persona_get_store (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = _data_->persona;
	_data_->_state_ = 1;
	folks_persona_store_remove_persona (_data_->_tmp2_, _data_->_tmp3_, folks_individual_aggregator_remove_persona_ready, _data_);
	return FALSE;
	_state_1:
	folks_persona_store_remove_persona_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void folks_individual_aggregator_link_personas_data_free (gpointer _data) {
	FolksIndividualAggregatorLinkPersonasData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->personas);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorLinkPersonasData, _data_);
}


void folks_individual_aggregator_link_personas (FolksIndividualAggregator* self, GeeSet* personas, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorLinkPersonasData* _data_;
	FolksIndividualAggregator* _tmp0_;
	GeeSet* _tmp1_;
	GeeSet* _tmp2_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorLinkPersonasData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_link_personas);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_link_personas_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = personas;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->personas);
	_data_->personas = _tmp2_;
	folks_individual_aggregator_link_personas_co (_data_);
}


void folks_individual_aggregator_link_personas_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividualAggregatorLinkPersonasData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


/**
   * Link the given {@link Persona}s together.
   *
   * Create links between the given {@link Persona}s so that they form a single
   * {@link Individual}. The new {@link Individual} will be returned via the
   * {@link IndividualAggregator.individuals_changed} signal.
   *
   * Removal of the {@link Individual}s which the {@link Persona}s were in
   * before is signalled by {@link IndividualAggregator.individuals_changed} and
   * {@link Individual.removed}.
   *
   * @param personas the {@link Persona}s to be linked
   * @throws IndividualAggregatorError.NO_PRIMARY_STORE if no primary store has
   * been configured for the individual aggregator
   * @throws IndividualAggregatorError if adding the linking persona failed —
   * this will be passed through from
   * {@link IndividualAggregator.add_persona_from_details}
   *
   * @since 0.5.1
   */
static void folks_individual_aggregator_link_personas_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorLinkPersonasData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_link_personas_co (_data_);
}


static gboolean folks_individual_aggregator_link_personas_co (FolksIndividualAggregatorLinkPersonasData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		case 2:
		goto _state_2;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = _data_->self->priv->_primary_store;
	if (_data_->_tmp0_ == NULL) {
		_data_->_tmp1_ = NULL;
		_data_->_tmp1_ = _ ("Can’t link personas with no primary store.");
		_data_->_tmp2_ = g_strconcat (_data_->_tmp1_, "\n", NULL);
		_data_->_tmp3_ = _data_->_tmp2_;
		_data_->_tmp4_ = NULL;
		_data_->_tmp4_ = _ ("Persona store ‘%s:%s’ is configured as primary, but could not be found" \
" or failed to load.");
		_data_->_tmp5_ = g_strconcat (_data_->_tmp3_, _data_->_tmp4_, NULL);
		_data_->_tmp6_ = _data_->_tmp5_;
		_data_->_tmp7_ = g_strconcat (_data_->_tmp6_, "\n", NULL);
		_data_->_tmp8_ = _data_->_tmp7_;
		_data_->_tmp9_ = NULL;
		_data_->_tmp9_ = _ ("Check the relevant service is running, or change the default store in " \
"that service or using the “%s” GSettings key.");
		_data_->_tmp10_ = g_strconcat (_data_->_tmp8_, _data_->_tmp9_, NULL);
		_data_->_tmp11_ = _data_->_tmp10_;
		_data_->_tmp12_ = _data_->self->priv->_configured_primary_store_type_id;
		_data_->_tmp13_ = _data_->self->priv->_configured_primary_store_id;
		_data_->_tmp14_ = NULL;
		_data_->_tmp14_ = g_strdup_printf ("%s %s", FOLKS_INDIVIDUAL_AGGREGATOR__FOLKS_GSETTINGS_SCHEMA, FOLKS_INDIVIDUAL_AGGREGATOR__PRIMARY_STORE_CONFIG_KEY);
		_data_->_tmp15_ = _data_->_tmp14_;
		_data_->_tmp16_ = g_error_new (FOLKS_INDIVIDUAL_AGGREGATOR_ERROR, FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_NO_PRIMARY_STORE, _data_->_tmp11_, _data_->_tmp12_, _data_->_tmp13_, _data_->_tmp15_);
		_data_->_tmp17_ = _data_->_tmp16_;
		_g_free0 (_data_->_tmp15_);
		_g_free0 (_data_->_tmp11_);
		_g_free0 (_data_->_tmp8_);
		_g_free0 (_data_->_tmp6_);
		_g_free0 (_data_->_tmp3_);
		_data_->_inner_error_ = _data_->_tmp17_;
		if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp18_ = _data_->personas;
	_data_->_tmp19_ = gee_collection_get_size ((GeeCollection*) _data_->_tmp18_);
	_data_->_tmp20_ = _data_->_tmp19_;
	if (_data_->_tmp20_ <= 1) {
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	_data_->_tmp21_ = _data_->self->priv->_linking_enabled;
	if (_data_->_tmp21_ == FALSE) {
		g_debug ("individual-aggregator.vala:1866: Can't link Personas: linking disabled" \
".");
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	{
		_data_->_tmp22_ = _data_->personas;
		_data_->_tmp23_ = NULL;
		_data_->_tmp23_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp22_);
		_data_->_p_it = _data_->_tmp23_;
		while (TRUE) {
			_data_->_tmp24_ = _data_->_p_it;
			_data_->_tmp25_ = FALSE;
			_data_->_tmp25_ = gee_iterator_next (_data_->_tmp24_);
			if (!_data_->_tmp25_) {
				break;
			}
			_data_->_tmp26_ = _data_->_p_it;
			_data_->_tmp27_ = NULL;
			_data_->_tmp27_ = gee_iterator_get (_data_->_tmp26_);
			_data_->p = (FolksPersona*) _data_->_tmp27_;
			_data_->_tmp28_ = _data_->p;
			_data_->_tmp29_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_data_->_tmp28_, FOLKS_TYPE_ANTI_LINKABLE) ? ((FolksAntiLinkable*) _data_->_tmp28_) : NULL);
			_data_->al = _data_->_tmp29_;
			_data_->_tmp30_ = _data_->al;
			if (_data_->_tmp30_ != NULL) {
				{
					_data_->_tmp31_ = _data_->al;
					_data_->_tmp32_ = _data_->personas;
					_data_->_state_ = 1;
					folks_anti_linkable_remove_anti_links (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp31_, FOLKS_TYPE_ANTI_LINKABLE, FolksAntiLinkable), _data_->_tmp32_, folks_individual_aggregator_link_personas_ready, _data_);
					return FALSE;
					_state_1:
					folks_anti_linkable_remove_anti_links_finish (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp31_, FOLKS_TYPE_ANTI_LINKABLE, FolksAntiLinkable), _data_->_res_, &_data_->_inner_error_);
					if (_data_->_inner_error_ != NULL) {
						if (_data_->_inner_error_->domain == FOLKS_PROPERTY_ERROR) {
							goto __catch19_folks_property_error;
						}
						_g_object_unref0 (_data_->al);
						_g_object_unref0 (_data_->p);
						_g_object_unref0 (_data_->_p_it);
						g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
						g_clear_error (&_data_->_inner_error_);
						return FALSE;
					}
				}
				goto __finally19;
				__catch19_folks_property_error:
				{
					_data_->e = _data_->_inner_error_;
					_data_->_inner_error_ = NULL;
					_data_->_tmp33_ = NULL;
					_data_->_tmp33_ = _ ("Anti-links can't be removed between personas being linked.");
					_data_->_tmp34_ = g_error_new_literal (FOLKS_INDIVIDUAL_AGGREGATOR_ERROR, FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_PROPERTY_NOT_WRITEABLE, _data_->_tmp33_);
					_data_->_inner_error_ = _data_->_tmp34_;
					_g_error_free0 (_data_->e);
					goto __finally19;
				}
				__finally19:
				if (_data_->_inner_error_ != NULL) {
					if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
						g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
						g_error_free (_data_->_inner_error_);
						_g_object_unref0 (_data_->al);
						_g_object_unref0 (_data_->p);
						_g_object_unref0 (_data_->_p_it);
						if (_data_->_state_ == 0) {
							g_simple_async_result_complete_in_idle (_data_->_async_result);
						} else {
							g_simple_async_result_complete (_data_->_async_result);
						}
						g_object_unref (_data_->_async_result);
						return FALSE;
					} else {
						_g_object_unref0 (_data_->al);
						_g_object_unref0 (_data_->p);
						_g_object_unref0 (_data_->_p_it);
						g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
						g_clear_error (&_data_->_inner_error_);
						return FALSE;
					}
				}
			}
			_g_object_unref0 (_data_->al);
			_g_object_unref0 (_data_->p);
		}
		_g_object_unref0 (_data_->_p_it);
	}
	_data_->_tmp35_ = _data_->self->priv->_primary_store;
	_data_->_tmp36_ = folks_persona_store_get_type_id (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp35_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore));
	_data_->_tmp37_ = _data_->_tmp36_;
	_data_->_tmp38_ = _data_->self->priv->_configured_primary_store_type_id;
	_vala_assert (g_strcmp0 (_data_->_tmp37_, _data_->_tmp38_) == 0, "((!) this._primary_store).type_id ==           this._configured_primary_store_type_id");
	_data_->_tmp39_ = _data_->personas;
	_data_->_tmp40_ = NULL;
	_data_->_tmp40_ = _folks_individual_aggregator_build_linking_details (_data_->self, _data_->_tmp39_);
	_data_->details = _data_->_tmp40_;
	_data_->_tmp41_ = _data_->self->priv->_primary_store;
	_data_->_tmp42_ = _data_->details;
	_data_->_state_ = 2;
	folks_individual_aggregator_add_persona_from_details (_data_->self, NULL, G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp41_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore), _data_->_tmp42_, folks_individual_aggregator_link_personas_ready, _data_);
	return FALSE;
	_state_2:
	_data_->_tmp43_ = NULL;
	_data_->_tmp43_ = folks_individual_aggregator_add_persona_from_details_finish (_data_->self, _data_->_res_, &_data_->_inner_error_);
	_data_->_tmp44_ = _data_->_tmp43_;
	_g_object_unref0 (_data_->_tmp44_);
	if (_data_->_inner_error_ != NULL) {
		if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_hash_table_unref0 (_data_->details);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_hash_table_unref0 (_data_->details);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_hash_table_unref0 (_data_->details);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static GHashTable* _folks_individual_aggregator_build_linking_details (FolksIndividualAggregator* self, GeeSet* personas) {
	GHashTable* result = NULL;
	GeeHashMultiMap* _tmp0_;
	GeeHashMultiMap* protocols_addrs_set;
	GeeHashMultiMap* _tmp1_;
	GeeHashMultiMap* web_service_addrs_set;
	GeeHashSet* _tmp2_;
	GeeHashSet* local_ids;
	GHashFunc _tmp76_;
	GEqualFunc _tmp77_;
	GHashTable* _tmp78_;
	GHashTable* details;
	GeeHashMultiMap* _tmp79_;
	gint _tmp80_;
	gint _tmp81_;
	GeeHashMultiMap* _tmp90_;
	gint _tmp91_;
	gint _tmp92_;
	GeeHashSet* _tmp101_;
	gint _tmp102_;
	gint _tmp103_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (personas != NULL, NULL);
	_tmp0_ = gee_hash_multi_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, FOLKS_TYPE_IM_FIELD_DETAILS, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, (GHashFunc) folks_abstract_field_details_hash, (GEqualFunc) folks_abstract_field_details_equal);
	protocols_addrs_set = _tmp0_;
	_tmp1_ = gee_hash_multi_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, FOLKS_TYPE_WEB_SERVICE_FIELD_DETAILS, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, (GHashFunc) folks_abstract_field_details_hash, (GEqualFunc) folks_abstract_field_details_equal);
	web_service_addrs_set = _tmp1_;
	_tmp2_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL);
	local_ids = _tmp2_;
	{
		GeeSet* _tmp3_;
		GeeIterator* _tmp4_ = NULL;
		GeeIterator* _persona_it;
		_tmp3_ = personas;
		_tmp4_ = gee_iterable_iterator ((GeeIterable*) _tmp3_);
		_persona_it = _tmp4_;
		while (TRUE) {
			GeeIterator* _tmp5_;
			gboolean _tmp6_ = FALSE;
			GeeIterator* _tmp7_;
			gpointer _tmp8_ = NULL;
			FolksPersona* persona;
			FolksPersona* _tmp9_;
			FolksPersona* _tmp37_;
			FolksPersona* _tmp65_;
			_tmp5_ = _persona_it;
			_tmp6_ = gee_iterator_next (_tmp5_);
			if (!_tmp6_) {
				break;
			}
			_tmp7_ = _persona_it;
			_tmp8_ = gee_iterator_get (_tmp7_);
			persona = (FolksPersona*) _tmp8_;
			_tmp9_ = persona;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, FOLKS_TYPE_IM_DETAILS)) {
				FolksPersona* _tmp10_;
				FolksImDetails* _tmp11_;
				FolksImDetails* im_details;
				_tmp10_ = persona;
				_tmp11_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, FOLKS_TYPE_IM_DETAILS, FolksImDetails));
				im_details = _tmp11_;
				{
					FolksImDetails* _tmp12_;
					GeeMultiMap* _tmp13_;
					GeeMultiMap* _tmp14_;
					GeeSet* _tmp15_ = NULL;
					GeeSet* _tmp16_;
					GeeIterator* _tmp17_ = NULL;
					GeeIterator* _tmp18_;
					GeeIterator* _protocol_it;
					_tmp12_ = im_details;
					_tmp13_ = folks_im_details_get_im_addresses (_tmp12_);
					_tmp14_ = _tmp13_;
					_tmp15_ = gee_multi_map_get_keys (_tmp14_);
					_tmp16_ = _tmp15_;
					_tmp17_ = gee_iterable_iterator ((GeeIterable*) _tmp16_);
					_tmp18_ = _tmp17_;
					_g_object_unref0 (_tmp16_);
					_protocol_it = _tmp18_;
					while (TRUE) {
						GeeIterator* _tmp19_;
						gboolean _tmp20_ = FALSE;
						GeeIterator* _tmp21_;
						gpointer _tmp22_ = NULL;
						gchar* protocol;
						FolksImDetails* _tmp23_;
						GeeMultiMap* _tmp24_;
						GeeMultiMap* _tmp25_;
						const gchar* _tmp26_;
						GeeCollection* _tmp27_ = NULL;
						GeeCollection* im_addresses;
						_tmp19_ = _protocol_it;
						_tmp20_ = gee_iterator_next (_tmp19_);
						if (!_tmp20_) {
							break;
						}
						_tmp21_ = _protocol_it;
						_tmp22_ = gee_iterator_get (_tmp21_);
						protocol = (gchar*) _tmp22_;
						_tmp23_ = im_details;
						_tmp24_ = folks_im_details_get_im_addresses (_tmp23_);
						_tmp25_ = _tmp24_;
						_tmp26_ = protocol;
						_tmp27_ = gee_multi_map_get (_tmp25_, _tmp26_);
						im_addresses = _tmp27_;
						{
							GeeCollection* _tmp28_;
							GeeIterator* _tmp29_ = NULL;
							GeeIterator* _im_address_it;
							_tmp28_ = im_addresses;
							_tmp29_ = gee_iterable_iterator ((GeeIterable*) _tmp28_);
							_im_address_it = _tmp29_;
							while (TRUE) {
								GeeIterator* _tmp30_;
								gboolean _tmp31_ = FALSE;
								GeeIterator* _tmp32_;
								gpointer _tmp33_ = NULL;
								FolksImFieldDetails* im_address;
								GeeHashMultiMap* _tmp34_;
								const gchar* _tmp35_;
								FolksImFieldDetails* _tmp36_;
								_tmp30_ = _im_address_it;
								_tmp31_ = gee_iterator_next (_tmp30_);
								if (!_tmp31_) {
									break;
								}
								_tmp32_ = _im_address_it;
								_tmp33_ = gee_iterator_get (_tmp32_);
								im_address = (FolksImFieldDetails*) _tmp33_;
								_tmp34_ = protocols_addrs_set;
								_tmp35_ = protocol;
								_tmp36_ = im_address;
								gee_multi_map_set ((GeeMultiMap*) _tmp34_, _tmp35_, _tmp36_);
								_g_object_unref0 (im_address);
							}
							_g_object_unref0 (_im_address_it);
						}
						_g_object_unref0 (im_addresses);
						_g_free0 (protocol);
					}
					_g_object_unref0 (_protocol_it);
				}
				_g_object_unref0 (im_details);
			}
			_tmp37_ = persona;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp37_, FOLKS_TYPE_WEB_SERVICE_DETAILS)) {
				FolksPersona* _tmp38_;
				FolksWebServiceDetails* _tmp39_;
				FolksWebServiceDetails* ws_details;
				_tmp38_ = persona;
				_tmp39_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, FOLKS_TYPE_WEB_SERVICE_DETAILS, FolksWebServiceDetails));
				ws_details = _tmp39_;
				{
					FolksWebServiceDetails* _tmp40_;
					GeeMultiMap* _tmp41_;
					GeeMultiMap* _tmp42_;
					GeeSet* _tmp43_ = NULL;
					GeeSet* _tmp44_;
					GeeIterator* _tmp45_ = NULL;
					GeeIterator* _tmp46_;
					GeeIterator* _web_service_it;
					_tmp40_ = ws_details;
					_tmp41_ = folks_web_service_details_get_web_service_addresses (_tmp40_);
					_tmp42_ = _tmp41_;
					_tmp43_ = gee_multi_map_get_keys (_tmp42_);
					_tmp44_ = _tmp43_;
					_tmp45_ = gee_iterable_iterator ((GeeIterable*) _tmp44_);
					_tmp46_ = _tmp45_;
					_g_object_unref0 (_tmp44_);
					_web_service_it = _tmp46_;
					while (TRUE) {
						GeeIterator* _tmp47_;
						gboolean _tmp48_ = FALSE;
						GeeIterator* _tmp49_;
						gpointer _tmp50_ = NULL;
						gchar* web_service;
						FolksWebServiceDetails* _tmp51_;
						GeeMultiMap* _tmp52_;
						GeeMultiMap* _tmp53_;
						const gchar* _tmp54_;
						GeeCollection* _tmp55_ = NULL;
						GeeCollection* ws_addresses;
						_tmp47_ = _web_service_it;
						_tmp48_ = gee_iterator_next (_tmp47_);
						if (!_tmp48_) {
							break;
						}
						_tmp49_ = _web_service_it;
						_tmp50_ = gee_iterator_get (_tmp49_);
						web_service = (gchar*) _tmp50_;
						_tmp51_ = ws_details;
						_tmp52_ = folks_web_service_details_get_web_service_addresses (_tmp51_);
						_tmp53_ = _tmp52_;
						_tmp54_ = web_service;
						_tmp55_ = gee_multi_map_get (_tmp53_, _tmp54_);
						ws_addresses = _tmp55_;
						{
							GeeCollection* _tmp56_;
							GeeIterator* _tmp57_ = NULL;
							GeeIterator* _ws_fd_it;
							_tmp56_ = ws_addresses;
							_tmp57_ = gee_iterable_iterator ((GeeIterable*) _tmp56_);
							_ws_fd_it = _tmp57_;
							while (TRUE) {
								GeeIterator* _tmp58_;
								gboolean _tmp59_ = FALSE;
								GeeIterator* _tmp60_;
								gpointer _tmp61_ = NULL;
								FolksWebServiceFieldDetails* ws_fd;
								GeeHashMultiMap* _tmp62_;
								const gchar* _tmp63_;
								FolksWebServiceFieldDetails* _tmp64_;
								_tmp58_ = _ws_fd_it;
								_tmp59_ = gee_iterator_next (_tmp58_);
								if (!_tmp59_) {
									break;
								}
								_tmp60_ = _ws_fd_it;
								_tmp61_ = gee_iterator_get (_tmp60_);
								ws_fd = (FolksWebServiceFieldDetails*) _tmp61_;
								_tmp62_ = web_service_addrs_set;
								_tmp63_ = web_service;
								_tmp64_ = ws_fd;
								gee_multi_map_set ((GeeMultiMap*) _tmp62_, _tmp63_, _tmp64_);
								_g_object_unref0 (ws_fd);
							}
							_g_object_unref0 (_ws_fd_it);
						}
						_g_object_unref0 (ws_addresses);
						_g_free0 (web_service);
					}
					_g_object_unref0 (_web_service_it);
				}
				_g_object_unref0 (ws_details);
			}
			_tmp65_ = persona;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp65_, FOLKS_TYPE_LOCAL_ID_DETAILS)) {
				{
					FolksPersona* _tmp66_;
					GeeSet* _tmp67_;
					GeeSet* _tmp68_;
					GeeIterator* _tmp69_ = NULL;
					GeeIterator* _id_it;
					_tmp66_ = persona;
					_tmp67_ = folks_local_id_details_get_local_ids (G_TYPE_CHECK_INSTANCE_CAST (_tmp66_, FOLKS_TYPE_LOCAL_ID_DETAILS, FolksLocalIdDetails));
					_tmp68_ = _tmp67_;
					_tmp69_ = gee_iterable_iterator ((GeeIterable*) _tmp68_);
					_id_it = _tmp69_;
					while (TRUE) {
						GeeIterator* _tmp70_;
						gboolean _tmp71_ = FALSE;
						GeeIterator* _tmp72_;
						gpointer _tmp73_ = NULL;
						gchar* id;
						GeeHashSet* _tmp74_;
						const gchar* _tmp75_;
						_tmp70_ = _id_it;
						_tmp71_ = gee_iterator_next (_tmp70_);
						if (!_tmp71_) {
							break;
						}
						_tmp72_ = _id_it;
						_tmp73_ = gee_iterator_get (_tmp72_);
						id = (gchar*) _tmp73_;
						_tmp74_ = local_ids;
						_tmp75_ = id;
						gee_abstract_collection_add ((GeeAbstractCollection*) _tmp74_, _tmp75_);
						_g_free0 (id);
					}
					_g_object_unref0 (_id_it);
				}
			}
			_g_object_unref0 (persona);
		}
		_g_object_unref0 (_persona_it);
	}
	_tmp76_ = g_str_hash;
	_tmp77_ = g_str_equal;
	_tmp78_ = g_hash_table_new_full (_tmp76_, _tmp77_, _g_free0_, __vala_GValue_free0_);
	details = _tmp78_;
	_tmp79_ = protocols_addrs_set;
	_tmp80_ = gee_multi_map_get_size ((GeeMultiMap*) _tmp79_);
	_tmp81_ = _tmp80_;
	if (_tmp81_ > 0) {
		GValue _tmp82_ = {0};
		GValue im_addresses_value;
		GeeHashMultiMap* _tmp83_;
		GHashTable* _tmp84_;
		const gchar* _tmp85_ = NULL;
		gchar* _tmp86_;
		GValue _tmp87_;
		GValue _tmp88_;
		GValue* _tmp89_;
		g_value_init (&_tmp82_, GEE_TYPE_MULTI_MAP);
		im_addresses_value = _tmp82_;
		_tmp83_ = protocols_addrs_set;
		g_value_set_object (&im_addresses_value, (GObject*) _tmp83_);
		_tmp84_ = details;
		_tmp85_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_IM_ADDRESSES);
		_tmp86_ = g_strdup ((const gchar*) _tmp85_);
		_tmp87_ = im_addresses_value;
		_tmp88_ = _tmp87_;
		_tmp89_ = __g_value_dup0 (&_tmp88_);
		g_hash_table_insert (_tmp84_, _tmp86_, _tmp89_);
		G_IS_VALUE (&im_addresses_value) ? (g_value_unset (&im_addresses_value), NULL) : NULL;
	}
	_tmp90_ = web_service_addrs_set;
	_tmp91_ = gee_multi_map_get_size ((GeeMultiMap*) _tmp90_);
	_tmp92_ = _tmp91_;
	if (_tmp92_ > 0) {
		GValue _tmp93_ = {0};
		GValue web_service_addresses_value;
		GeeHashMultiMap* _tmp94_;
		GHashTable* _tmp95_;
		const gchar* _tmp96_ = NULL;
		gchar* _tmp97_;
		GValue _tmp98_;
		GValue _tmp99_;
		GValue* _tmp100_;
		g_value_init (&_tmp93_, GEE_TYPE_MULTI_MAP);
		web_service_addresses_value = _tmp93_;
		_tmp94_ = web_service_addrs_set;
		g_value_set_object (&web_service_addresses_value, (GObject*) _tmp94_);
		_tmp95_ = details;
		_tmp96_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_WEB_SERVICE_ADDRESSES);
		_tmp97_ = g_strdup ((const gchar*) _tmp96_);
		_tmp98_ = web_service_addresses_value;
		_tmp99_ = _tmp98_;
		_tmp100_ = __g_value_dup0 (&_tmp99_);
		g_hash_table_insert (_tmp95_, _tmp97_, _tmp100_);
		G_IS_VALUE (&web_service_addresses_value) ? (g_value_unset (&web_service_addresses_value), NULL) : NULL;
	}
	_tmp101_ = local_ids;
	_tmp102_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp101_);
	_tmp103_ = _tmp102_;
	if (_tmp103_ > 0) {
		GValue _tmp104_ = {0};
		GValue local_ids_value;
		GeeHashSet* _tmp105_;
		GHashTable* _tmp106_;
		const gchar* _tmp107_ = NULL;
		gchar* _tmp108_;
		GValue _tmp109_;
		GValue _tmp110_;
		GValue* _tmp111_;
		g_value_init (&_tmp104_, GEE_TYPE_SET);
		local_ids_value = _tmp104_;
		_tmp105_ = local_ids;
		g_value_set_object (&local_ids_value, (GObject*) _tmp105_);
		_tmp106_ = details;
		_tmp107_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_LOCAL_IDS);
		_tmp108_ = g_strdup ((const gchar*) _tmp107_);
		_tmp109_ = local_ids_value;
		_tmp110_ = _tmp109_;
		_tmp111_ = __g_value_dup0 (&_tmp110_);
		g_hash_table_insert (_tmp106_, _tmp108_, _tmp111_);
		G_IS_VALUE (&local_ids_value) ? (g_value_unset (&local_ids_value), NULL) : NULL;
	}
	result = details;
	_g_object_unref0 (local_ids);
	_g_object_unref0 (web_service_addrs_set);
	_g_object_unref0 (protocols_addrs_set);
	return result;
}


static void folks_individual_aggregator_unlink_individual_data_free (gpointer _data) {
	FolksIndividualAggregatorUnlinkIndividualData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->individual);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorUnlinkIndividualData, _data_);
}


void folks_individual_aggregator_unlink_individual (FolksIndividualAggregator* self, FolksIndividual* individual, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorUnlinkIndividualData* _data_;
	FolksIndividualAggregator* _tmp0_;
	FolksIndividual* _tmp1_;
	FolksIndividual* _tmp2_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorUnlinkIndividualData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_unlink_individual);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_unlink_individual_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = individual;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->individual);
	_data_->individual = _tmp2_;
	folks_individual_aggregator_unlink_individual_co (_data_);
}


void folks_individual_aggregator_unlink_individual_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividualAggregatorUnlinkIndividualData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


/**
   * Unlinks the given {@link Individual} into its constituent {@link Persona}s.
   *
   * This completely unlinks the given {@link Individual}, destroying all of
   * its writeable {@link Persona}s.
   *
   * The {@link Individual}'s removal is signalled by
   * {@link IndividualAggregator.individuals_changed} and
   * {@link Individual.removed}.
   *
   * The {@link Persona}s comprising the {@link Individual} will be re-linked
   * into one or more new {@link Individual}s, depending on how much linking
   * data remains (typically only implicit links remain). The addition of these
   * new {@link Individual}s will be signalled by
   * {@link IndividualAggregator.individuals_changed}.
   *
   * @param individual the {@link Individual} to unlink
   * @throws GLib.Error if removing the linking persona failed — this will be
   * passed through from {@link PersonaStore.remove_persona}
   *
   * @since 0.1.13
   */
static void folks_individual_aggregator_unlink_individual_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorUnlinkIndividualData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_unlink_individual_co (_data_);
}


static gboolean folks_individual_aggregator_unlink_individual_co (FolksIndividualAggregatorUnlinkIndividualData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		case 2:
		goto _state_2;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = _data_->self->priv->_linking_enabled;
	if (_data_->_tmp0_ == FALSE) {
		_data_->_tmp1_ = _data_->individual;
		_data_->_tmp2_ = folks_individual_get_id (_data_->_tmp1_);
		_data_->_tmp3_ = _data_->_tmp2_;
		g_debug ("individual-aggregator.vala:2018: Can't unlink Individual '%s': linking" \
" disabled.", _data_->_tmp3_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	_data_->_tmp4_ = _data_->individual;
	_data_->_tmp5_ = folks_individual_get_id (_data_->_tmp4_);
	_data_->_tmp6_ = _data_->_tmp5_;
	g_debug ("individual-aggregator.vala:2023: Unlinking Individual '%s':", _data_->_tmp6_);
	_data_->_tmp7_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	_data_->individual_personas = _data_->_tmp7_;
	_data_->_tmp8_ = _data_->individual_personas;
	_data_->_tmp9_ = _data_->individual;
	_data_->_tmp10_ = folks_individual_get_personas (_data_->_tmp9_);
	_data_->_tmp11_ = _data_->_tmp10_;
	gee_abstract_collection_add_all ((GeeAbstractCollection*) _data_->_tmp8_, (GeeCollection*) _data_->_tmp11_);
	g_debug ("individual-aggregator.vala:2039:     Inserting anti-links:");
	{
		_data_->_tmp12_ = _data_->individual_personas;
		_data_->_tmp13_ = NULL;
		_data_->_tmp13_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _data_->_tmp12_);
		_data_->_pers_it = _data_->_tmp13_;
		while (TRUE) {
			_data_->_tmp14_ = _data_->_pers_it;
			_data_->_tmp15_ = FALSE;
			_data_->_tmp15_ = gee_iterator_next (_data_->_tmp14_);
			if (!_data_->_tmp15_) {
				break;
			}
			_data_->_tmp16_ = _data_->_pers_it;
			_data_->_tmp17_ = NULL;
			_data_->_tmp17_ = gee_iterator_get (_data_->_tmp16_);
			_data_->pers = (FolksPersona*) _data_->_tmp17_;
			{
				_data_->_tmp18_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
				_data_->personas = _data_->_tmp18_;
				_data_->_tmp19_ = _data_->personas;
				_data_->_tmp20_ = _data_->pers;
				gee_abstract_collection_add ((GeeAbstractCollection*) _data_->_tmp19_, _data_->_tmp20_);
				_data_->_tmp21_ = _data_->pers;
				_data_->_tmp22_ = folks_persona_get_uid (_data_->_tmp21_);
				_data_->_tmp23_ = _data_->_tmp22_;
				_data_->_tmp24_ = _data_->pers;
				g_message ("individual-aggregator.vala:2046: Anti-linking persona '%s' (%p)", _data_->_tmp23_, _data_->_tmp24_);
				_data_->_tmp25_ = _data_->personas;
				_data_->_state_ = 1;
				_folks_individual_aggregator_ensure_personas_property_writeable (_data_->self, (GeeSet*) _data_->_tmp25_, "anti-links", folks_individual_aggregator_unlink_individual_ready, _data_);
				return FALSE;
				_state_1:
				_data_->_tmp26_ = NULL;
				_data_->_tmp26_ = _folks_individual_aggregator_ensure_personas_property_writeable_finish (_data_->self, _data_->_res_, &_data_->_inner_error_);
				_data_->writeable_persona = _data_->_tmp26_;
				if (_data_->_inner_error_ != NULL) {
					_g_object_unref0 (_data_->personas);
					if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
						goto __catch20_folks_individual_aggregator_error;
					}
					_g_object_unref0 (_data_->personas);
					_g_object_unref0 (_data_->pers);
					_g_object_unref0 (_data_->_pers_it);
					_g_object_unref0 (_data_->individual_personas);
					g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
					g_clear_error (&_data_->_inner_error_);
					return FALSE;
				}
				_data_->_tmp27_ = _data_->writeable_persona;
				_data_->_tmp28_ = folks_persona_get_uid (_data_->_tmp27_);
				_data_->_tmp29_ = _data_->_tmp28_;
				_data_->_tmp30_ = _data_->writeable_persona;
				g_message ("individual-aggregator.vala:2051: Writeable persona '%s' (%p)", _data_->_tmp29_, _data_->_tmp30_);
				_data_->_tmp31_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
				_data_->anti_link_personas = _data_->_tmp31_;
				_data_->_tmp32_ = _data_->anti_link_personas;
				_data_->_tmp33_ = _data_->individual_personas;
				gee_abstract_collection_add_all ((GeeAbstractCollection*) _data_->_tmp32_, (GeeCollection*) _data_->_tmp33_);
				_data_->_tmp34_ = _data_->anti_link_personas;
				_data_->_tmp35_ = _data_->pers;
				gee_abstract_collection_remove ((GeeAbstractCollection*) _data_->_tmp34_, _data_->_tmp35_);
				_data_->_tmp36_ = _data_->writeable_persona;
				_data_->_tmp37_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_data_->_tmp36_, FOLKS_TYPE_ANTI_LINKABLE) ? ((FolksAntiLinkable*) _data_->_tmp36_) : NULL);
				_data_->al = _data_->_tmp37_;
				_data_->_tmp38_ = _data_->al;
				_vala_assert (_data_->_tmp38_ != NULL, "al != null");
				_data_->_tmp39_ = _data_->al;
				_data_->_tmp40_ = _data_->anti_link_personas;
				_data_->_state_ = 2;
				folks_anti_linkable_add_anti_links (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp39_, FOLKS_TYPE_ANTI_LINKABLE, FolksAntiLinkable), (GeeSet*) _data_->_tmp40_, folks_individual_aggregator_unlink_individual_ready, _data_);
				return FALSE;
				_state_2:
				folks_anti_linkable_add_anti_links_finish (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp39_, FOLKS_TYPE_ANTI_LINKABLE, FolksAntiLinkable), _data_->_res_, &_data_->_inner_error_);
				if (_data_->_inner_error_ != NULL) {
					_g_object_unref0 (_data_->al);
					_g_object_unref0 (_data_->anti_link_personas);
					_g_object_unref0 (_data_->writeable_persona);
					_g_object_unref0 (_data_->personas);
					if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
						goto __catch20_folks_individual_aggregator_error;
					}
					goto __finally20;
				}
				g_message ("individual-aggregator.vala:2061: ");
				_g_object_unref0 (_data_->al);
				_g_object_unref0 (_data_->anti_link_personas);
				_g_object_unref0 (_data_->writeable_persona);
				_g_object_unref0 (_data_->personas);
			}
			goto __finally20;
			__catch20_folks_individual_aggregator_error:
			{
				_data_->e1 = _data_->_inner_error_;
				_data_->_inner_error_ = NULL;
				_data_->_tmp41_ = _data_->e1;
				_data_->_tmp42_ = _data_->_tmp41_->message;
				g_debug ("    Failed to ensure anti-links property is writeable " "(continuing anyway): %s", _data_->_tmp42_);
				_g_error_free0 (_data_->e1);
			}
			__finally20:
			if (_data_->_inner_error_ != NULL) {
				g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
				g_error_free (_data_->_inner_error_);
				_g_object_unref0 (_data_->pers);
				_g_object_unref0 (_data_->_pers_it);
				_g_object_unref0 (_data_->individual_personas);
				if (_data_->_state_ == 0) {
					g_simple_async_result_complete_in_idle (_data_->_async_result);
				} else {
					g_simple_async_result_complete (_data_->_async_result);
				}
				g_object_unref (_data_->_async_result);
				return FALSE;
			}
			_g_object_unref0 (_data_->pers);
		}
		_g_object_unref0 (_data_->_pers_it);
	}
	_g_object_unref0 (_data_->individual_personas);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void folks_individual_aggregator_ensure_individual_property_writeable_data_free (gpointer _data) {
	FolksIndividualAggregatorEnsureIndividualPropertyWriteableData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->individual);
	_g_free0 (_data_->property_name);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorEnsureIndividualPropertyWriteableData, _data_);
}


void folks_individual_aggregator_ensure_individual_property_writeable (FolksIndividualAggregator* self, FolksIndividual* individual, const gchar* property_name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorEnsureIndividualPropertyWriteableData* _data_;
	FolksIndividualAggregator* _tmp0_;
	FolksIndividual* _tmp1_;
	FolksIndividual* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorEnsureIndividualPropertyWriteableData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_ensure_individual_property_writeable);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_ensure_individual_property_writeable_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = individual;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->individual);
	_data_->individual = _tmp2_;
	_tmp3_ = property_name;
	_tmp4_ = g_strdup (_tmp3_);
	_g_free0 (_data_->property_name);
	_data_->property_name = _tmp4_;
	folks_individual_aggregator_ensure_individual_property_writeable_co (_data_);
}


FolksPersona* folks_individual_aggregator_ensure_individual_property_writeable_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksPersona* result;
	FolksIndividualAggregatorEnsureIndividualPropertyWriteableData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


/**
   * Ensure that the given property is writeable for the given
   * {@link Individual}.
   *
   * This makes sure that there is at least one {@link Persona} in the
   * individual which has ``property_name`` in its
   * {@link Persona.writeable_properties}. If no such persona exists in the
   * individual, a new one will be created and linked to the individual. (Note
   * that due to the design of the aggregator, this will result in the previous
   * individual being removed and replaced by a new one with the new persona;
   * listen to the {@link Individual.removed} signal to see the replacement.)
   *
   * It may not be possible to create a new persona which has the given property
   * as writeable. In that case, a
   * {@link IndividualAggregatorError.NO_PRIMARY_STORE} or
   * {@link IndividualAggregatorError.PROPERTY_NOT_WRITEABLE} error will be
   * thrown.
   *
   * @param individual the individual for which ``property_name`` should be
   * writeable
   * @param property_name the name of the property which needs to be writeable
   * (this should be in lower case using hyphens, e.g. “web-service-addresses”)
   * @return a persona (new or existing) which has the given property as
   * writeable
   * @throws IndividualAggregatorError.NO_PRIMARY_STORE if no primary store was
   * configured for this individual aggregator
   * @throws IndividualAggregatorError.PROPERTY_NOT_WRITEABLE if the given
   * ``property_name`` referred to a non-writeable property
   * @throws IndividualAggregatorError if adding a new persona (using
   * {@link IndividualAggregator.add_persona_from_details}) failed, or if
   * linking personas (using {@link IndividualAggregator.link_personas}) failed
   *
   * @since 0.6.2
   */
static void folks_individual_aggregator_ensure_individual_property_writeable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorEnsureIndividualPropertyWriteableData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_ensure_individual_property_writeable_co (_data_);
}


static gboolean folks_individual_aggregator_ensure_individual_property_writeable_co (FolksIndividualAggregatorEnsureIndividualPropertyWriteableData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = _data_->individual;
	_data_->_tmp1_ = folks_individual_get_id (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = _data_->property_name;
	g_debug ("individual-aggregator.vala:2109: ensure_individual_property_writeable:" \
" %s, %s", _data_->_tmp2_, _data_->_tmp3_);
	_data_->_tmp4_ = _data_->individual;
	_data_->_tmp5_ = folks_individual_get_personas (_data_->_tmp4_);
	_data_->_tmp6_ = _data_->_tmp5_;
	_data_->_tmp7_ = _data_->property_name;
	_data_->_state_ = 1;
	_folks_individual_aggregator_ensure_personas_property_writeable (_data_->self, _data_->_tmp6_, _data_->_tmp7_, folks_individual_aggregator_ensure_individual_property_writeable_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp8_ = NULL;
	_data_->_tmp8_ = _folks_individual_aggregator_ensure_personas_property_writeable_finish (_data_->self, _data_->_res_, &_data_->_inner_error_);
	_data_->p = _data_->_tmp8_;
	if (_data_->_inner_error_ != NULL) {
		if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->result = _data_->p;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->p);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void _folks_individual_aggregator_ensure_personas_property_writeable_data_free (gpointer _data) {
	FolksIndividualAggregatorEnsurePersonasPropertyWriteableData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->personas);
	_g_free0 (_data_->property_name);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorEnsurePersonasPropertyWriteableData, _data_);
}


static void _folks_individual_aggregator_ensure_personas_property_writeable (FolksIndividualAggregator* self, GeeSet* personas, const gchar* property_name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorEnsurePersonasPropertyWriteableData* _data_;
	FolksIndividualAggregator* _tmp0_;
	GeeSet* _tmp1_;
	GeeSet* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorEnsurePersonasPropertyWriteableData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, _folks_individual_aggregator_ensure_personas_property_writeable);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, _folks_individual_aggregator_ensure_personas_property_writeable_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = personas;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->personas);
	_data_->personas = _tmp2_;
	_tmp3_ = property_name;
	_tmp4_ = g_strdup (_tmp3_);
	_g_free0 (_data_->property_name);
	_data_->property_name = _tmp4_;
	_folks_individual_aggregator_ensure_personas_property_writeable_co (_data_);
}


static FolksPersona* _folks_individual_aggregator_ensure_personas_property_writeable_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksPersona* result;
	FolksIndividualAggregatorEnsurePersonasPropertyWriteableData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean _vala_string_array_contains (gchar** stack, int stack_length, gchar* needle) {
	int i;
	for (i = 0; i < stack_length; i++) {
		if (g_strcmp0 (stack[i], needle) == 0) {
			return TRUE;
		}
	}
	return FALSE;
}


static void _folks_individual_aggregator_ensure_personas_property_writeable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorEnsurePersonasPropertyWriteableData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	_folks_individual_aggregator_ensure_personas_property_writeable_co (_data_);
}


static gboolean _folks_individual_aggregator_ensure_personas_property_writeable_co (FolksIndividualAggregatorEnsurePersonasPropertyWriteableData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		case 2:
		goto _state_2;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	{
		_data_->_tmp0_ = _data_->personas;
		_data_->_tmp1_ = NULL;
		_data_->_tmp1_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp0_);
		_data_->_p1_it = _data_->_tmp1_;
		while (TRUE) {
			_data_->_tmp2_ = _data_->_p1_it;
			_data_->_tmp3_ = FALSE;
			_data_->_tmp3_ = gee_iterator_next (_data_->_tmp2_);
			if (!_data_->_tmp3_) {
				break;
			}
			_data_->_tmp4_ = _data_->_p1_it;
			_data_->_tmp5_ = NULL;
			_data_->_tmp5_ = gee_iterator_get (_data_->_tmp4_);
			_data_->p1 = (FolksPersona*) _data_->_tmp5_;
			_data_->_tmp6_ = _data_->property_name;
			_data_->_tmp7_ = _data_->p1;
			_data_->_tmp8_ = folks_persona_get_writeable_properties (_data_->_tmp7_, &_data_->_tmp8__length1);
			_data_->_tmp9_ = _data_->_tmp8_;
			_data_->_tmp9__length1 = _data_->_tmp8__length1;
			if (_vala_string_array_contains (_data_->_tmp9_, _data_->_tmp9__length1, _data_->_tmp6_)) {
				_data_->_tmp10_ = _data_->p1;
				_data_->_tmp11_ = folks_persona_get_uid (_data_->_tmp10_);
				_data_->_tmp12_ = _data_->_tmp11_;
				g_debug ("individual-aggregator.vala:2126:     Returning existing persona: %s", _data_->_tmp12_);
				_data_->result = _data_->p1;
				_g_object_unref0 (_data_->_p1_it);
				if (_data_->_state_ == 0) {
					g_simple_async_result_complete_in_idle (_data_->_async_result);
				} else {
					g_simple_async_result_complete (_data_->_async_result);
				}
				g_object_unref (_data_->_async_result);
				return FALSE;
			}
			_g_object_unref0 (_data_->p1);
		}
		_g_object_unref0 (_data_->_p1_it);
	}
	_data_->_tmp13_ = _data_->personas;
	_data_->_tmp14_ = NULL;
	_data_->_tmp14_ = _folks_individual_aggregator_build_linking_details (_data_->self, _data_->_tmp13_);
	_data_->details = _data_->_tmp14_;
	_data_->new_persona = NULL;
	_data_->_tmp16_ = _data_->self->priv->_primary_store;
	if (_data_->_tmp16_ != NULL) {
		_data_->_tmp17_ = _data_->property_name;
		_data_->_tmp18_ = _data_->self->priv->_primary_store;
		_data_->_tmp19_ = folks_persona_store_get_always_writeable_properties (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp18_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore), &_data_->_tmp19__length1);
		_data_->_tmp20_ = _data_->_tmp19_;
		_data_->_tmp20__length1 = _data_->_tmp19__length1;
		_data_->_tmp15_ = _vala_string_array_contains (_data_->_tmp20_, _data_->_tmp20__length1, _data_->_tmp17_);
	} else {
		_data_->_tmp15_ = FALSE;
	}
	_data_->_tmp21_ = _data_->_tmp15_;
	if (_data_->_tmp21_) {
		{
			g_debug ("individual-aggregator.vala:2143:     Using writeable store");
			_data_->_tmp22_ = _data_->self->priv->_primary_store;
			_data_->_tmp23_ = _data_->details;
			_data_->_state_ = 1;
			folks_individual_aggregator_add_persona_from_details (_data_->self, NULL, G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp22_, FOLKS_TYPE_PERSONA_STORE, FolksPersonaStore), _data_->_tmp23_, _folks_individual_aggregator_ensure_personas_property_writeable_ready, _data_);
			return FALSE;
			_state_1:
			_data_->_tmp24_ = NULL;
			_data_->_tmp24_ = folks_individual_aggregator_add_persona_from_details_finish (_data_->self, _data_->_res_, &_data_->_inner_error_);
			_data_->_tmp25_ = _data_->_tmp24_;
			if (_data_->_inner_error_ != NULL) {
				if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
					goto __catch21_folks_individual_aggregator_error;
				}
				_g_object_unref0 (_data_->new_persona);
				_g_hash_table_unref0 (_data_->details);
				g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
				g_clear_error (&_data_->_inner_error_);
				return FALSE;
			}
			_g_object_unref0 (_data_->new_persona);
			_data_->new_persona = _data_->_tmp25_;
		}
		goto __finally21;
		__catch21_folks_individual_aggregator_error:
		{
			_data_->e1 = _data_->_inner_error_;
			_data_->_inner_error_ = NULL;
			_g_object_unref0 (_data_->new_persona);
			_data_->new_persona = NULL;
			_g_error_free0 (_data_->e1);
		}
		__finally21:
		if (_data_->_inner_error_ != NULL) {
			if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
				g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
				g_error_free (_data_->_inner_error_);
				_g_object_unref0 (_data_->new_persona);
				_g_hash_table_unref0 (_data_->details);
				if (_data_->_state_ == 0) {
					g_simple_async_result_complete_in_idle (_data_->_async_result);
				} else {
					g_simple_async_result_complete (_data_->_async_result);
				}
				g_object_unref (_data_->_async_result);
				return FALSE;
			} else {
				_g_object_unref0 (_data_->new_persona);
				_g_hash_table_unref0 (_data_->details);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
				g_clear_error (&_data_->_inner_error_);
				return FALSE;
			}
		}
	}
	_data_->_tmp26_ = _data_->new_persona;
	if (_data_->_tmp26_ == NULL) {
		{
			_data_->_tmp27_ = _data_->self->priv->_stores;
			_data_->_tmp28_ = gee_abstract_map_get_values ((GeeMap*) _data_->_tmp27_);
			_data_->_tmp29_ = _data_->_tmp28_;
			_data_->_tmp30_ = _data_->_tmp29_;
			_data_->_tmp31_ = NULL;
			_data_->_tmp31_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp30_);
			_data_->_tmp32_ = _data_->_tmp31_;
			_g_object_unref0 (_data_->_tmp30_);
			_data_->_s_it = _data_->_tmp32_;
			while (TRUE) {
				_data_->_tmp33_ = _data_->_s_it;
				_data_->_tmp34_ = FALSE;
				_data_->_tmp34_ = gee_iterator_next (_data_->_tmp33_);
				if (!_data_->_tmp34_) {
					break;
				}
				_data_->_tmp35_ = _data_->_s_it;
				_data_->_tmp36_ = NULL;
				_data_->_tmp36_ = gee_iterator_get (_data_->_tmp35_);
				_data_->s = (FolksPersonaStore*) _data_->_tmp36_;
				_data_->_tmp38_ = _data_->s;
				_data_->_tmp39_ = _data_->self->priv->_primary_store;
				if (_data_->_tmp38_ == _data_->_tmp39_) {
					_data_->_tmp37_ = TRUE;
				} else {
					_data_->_tmp40_ = _data_->property_name;
					_data_->_tmp41_ = _data_->s;
					_data_->_tmp42_ = folks_persona_store_get_always_writeable_properties (_data_->_tmp41_, &_data_->_tmp42__length1);
					_data_->_tmp43_ = _data_->_tmp42_;
					_data_->_tmp43__length1 = _data_->_tmp42__length1;
					_data_->_tmp37_ = !_vala_string_array_contains (_data_->_tmp43_, _data_->_tmp43__length1, _data_->_tmp40_);
				}
				_data_->_tmp44_ = _data_->_tmp37_;
				if (_data_->_tmp44_) {
					_g_object_unref0 (_data_->s);
					continue;
				}
				{
					_data_->_tmp45_ = _data_->s;
					_data_->_tmp46_ = folks_persona_store_get_id (_data_->_tmp45_);
					_data_->_tmp47_ = _data_->_tmp46_;
					g_debug ("individual-aggregator.vala:2167:     Using store %s", _data_->_tmp47_);
					_data_->_tmp48_ = _data_->s;
					_data_->_tmp49_ = _data_->details;
					_data_->_state_ = 2;
					folks_individual_aggregator_add_persona_from_details (_data_->self, NULL, _data_->_tmp48_, _data_->_tmp49_, _folks_individual_aggregator_ensure_personas_property_writeable_ready, _data_);
					return FALSE;
					_state_2:
					_data_->_tmp50_ = NULL;
					_data_->_tmp50_ = folks_individual_aggregator_add_persona_from_details_finish (_data_->self, _data_->_res_, &_data_->_inner_error_);
					_data_->_tmp51_ = _data_->_tmp50_;
					if (_data_->_inner_error_ != NULL) {
						if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
							goto __catch22_folks_individual_aggregator_error;
						}
						_g_object_unref0 (_data_->s);
						_g_object_unref0 (_data_->_s_it);
						_g_object_unref0 (_data_->new_persona);
						_g_hash_table_unref0 (_data_->details);
						g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
						g_clear_error (&_data_->_inner_error_);
						return FALSE;
					}
					_g_object_unref0 (_data_->new_persona);
					_data_->new_persona = _data_->_tmp51_;
				}
				goto __finally22;
				__catch22_folks_individual_aggregator_error:
				{
					_data_->e2 = _data_->_inner_error_;
					_data_->_inner_error_ = NULL;
					_g_object_unref0 (_data_->new_persona);
					_data_->new_persona = NULL;
					_g_error_free0 (_data_->e2);
					_g_object_unref0 (_data_->s);
					continue;
				}
				__finally22:
				if (_data_->_inner_error_ != NULL) {
					if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
						g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
						g_error_free (_data_->_inner_error_);
						_g_object_unref0 (_data_->s);
						_g_object_unref0 (_data_->_s_it);
						_g_object_unref0 (_data_->new_persona);
						_g_hash_table_unref0 (_data_->details);
						if (_data_->_state_ == 0) {
							g_simple_async_result_complete_in_idle (_data_->_async_result);
						} else {
							g_simple_async_result_complete (_data_->_async_result);
						}
						g_object_unref (_data_->_async_result);
						return FALSE;
					} else {
						_g_object_unref0 (_data_->s);
						_g_object_unref0 (_data_->_s_it);
						_g_object_unref0 (_data_->new_persona);
						_g_hash_table_unref0 (_data_->details);
						g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
						g_clear_error (&_data_->_inner_error_);
						return FALSE;
					}
				}
				_g_object_unref0 (_data_->s);
			}
			_g_object_unref0 (_data_->_s_it);
		}
	}
	_data_->_tmp53_ = _data_->new_persona;
	if (_data_->_tmp53_ == NULL) {
		_data_->_tmp54_ = _data_->self->priv->_primary_store;
		_data_->_tmp52_ = _data_->_tmp54_ == NULL;
	} else {
		_data_->_tmp52_ = FALSE;
	}
	_data_->_tmp55_ = _data_->_tmp52_;
	if (_data_->_tmp55_) {
		_data_->_tmp56_ = NULL;
		_data_->_tmp56_ = _ ("Can’t add personas with no primary store.");
		_data_->_tmp57_ = g_strconcat (_data_->_tmp56_, "\n", NULL);
		_data_->_tmp58_ = _data_->_tmp57_;
		_data_->_tmp59_ = NULL;
		_data_->_tmp59_ = _ ("Persona store ‘%s:%s’ is configured as primary, but could not be found" \
" or failed to load.");
		_data_->_tmp60_ = g_strconcat (_data_->_tmp58_, _data_->_tmp59_, NULL);
		_data_->_tmp61_ = _data_->_tmp60_;
		_data_->_tmp62_ = g_strconcat (_data_->_tmp61_, "\n", NULL);
		_data_->_tmp63_ = _data_->_tmp62_;
		_data_->_tmp64_ = NULL;
		_data_->_tmp64_ = _ ("Check the relevant service is running, or change the default store in " \
"that service or using the “%s” GSettings key.");
		_data_->_tmp65_ = g_strconcat (_data_->_tmp63_, _data_->_tmp64_, NULL);
		_data_->_tmp66_ = _data_->_tmp65_;
		_data_->_tmp67_ = _data_->self->priv->_configured_primary_store_type_id;
		_data_->_tmp68_ = _data_->self->priv->_configured_primary_store_id;
		_data_->_tmp69_ = NULL;
		_data_->_tmp69_ = g_strdup_printf ("%s %s", FOLKS_INDIVIDUAL_AGGREGATOR__FOLKS_GSETTINGS_SCHEMA, FOLKS_INDIVIDUAL_AGGREGATOR__PRIMARY_STORE_CONFIG_KEY);
		_data_->_tmp70_ = _data_->_tmp69_;
		_data_->_tmp71_ = g_error_new (FOLKS_INDIVIDUAL_AGGREGATOR_ERROR, FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_NO_PRIMARY_STORE, _data_->_tmp66_, _data_->_tmp67_, _data_->_tmp68_, _data_->_tmp70_);
		_data_->_tmp72_ = _data_->_tmp71_;
		_g_free0 (_data_->_tmp70_);
		_g_free0 (_data_->_tmp66_);
		_g_free0 (_data_->_tmp63_);
		_g_free0 (_data_->_tmp61_);
		_g_free0 (_data_->_tmp58_);
		_data_->_inner_error_ = _data_->_tmp72_;
		if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->new_persona);
			_g_hash_table_unref0 (_data_->details);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->new_persona);
			_g_hash_table_unref0 (_data_->details);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	} else {
		_data_->_tmp73_ = _data_->new_persona;
		if (_data_->_tmp73_ == NULL) {
			_data_->_tmp74_ = NULL;
			_data_->_tmp74_ = _ ("Can't write to requested property (“%s”) of the writeable store.");
			_data_->_tmp75_ = _data_->property_name;
			_data_->_tmp76_ = g_error_new (FOLKS_INDIVIDUAL_AGGREGATOR_ERROR, FOLKS_INDIVIDUAL_AGGREGATOR_ERROR_PROPERTY_NOT_WRITEABLE, _data_->_tmp74_, _data_->_tmp75_);
			_data_->_inner_error_ = _data_->_tmp76_;
			if (_data_->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
				g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
				g_error_free (_data_->_inner_error_);
				_g_object_unref0 (_data_->new_persona);
				_g_hash_table_unref0 (_data_->details);
				if (_data_->_state_ == 0) {
					g_simple_async_result_complete_in_idle (_data_->_async_result);
				} else {
					g_simple_async_result_complete (_data_->_async_result);
				}
				g_object_unref (_data_->_async_result);
				return FALSE;
			} else {
				_g_object_unref0 (_data_->new_persona);
				_g_hash_table_unref0 (_data_->details);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
				g_clear_error (&_data_->_inner_error_);
				return FALSE;
			}
		}
	}
	_data_->_tmp77_ = _data_->new_persona;
	_data_->_tmp78_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp77_, FOLKS_TYPE_PERSONA, FolksPersona));
	_data_->result = _data_->_tmp78_;
	_g_object_unref0 (_data_->new_persona);
	_g_hash_table_unref0 (_data_->details);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->new_persona);
	_g_hash_table_unref0 (_data_->details);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void folks_individual_aggregator_look_up_individual_data_free (gpointer _data) {
	FolksIndividualAggregatorLookUpIndividualData* _data_;
	_data_ = _data;
	_g_free0 (_data_->id);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (FolksIndividualAggregatorLookUpIndividualData, _data_);
}


void folks_individual_aggregator_look_up_individual (FolksIndividualAggregator* self, const gchar* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	FolksIndividualAggregatorLookUpIndividualData* _data_;
	FolksIndividualAggregator* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	_data_ = g_slice_new0 (FolksIndividualAggregatorLookUpIndividualData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, folks_individual_aggregator_look_up_individual);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_individual_aggregator_look_up_individual_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = id;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->id);
	_data_->id = _tmp2_;
	folks_individual_aggregator_look_up_individual_co (_data_);
}


FolksIndividual* folks_individual_aggregator_look_up_individual_finish (FolksIndividualAggregator* self, GAsyncResult* _res_, GError** error) {
	FolksIndividual* result;
	FolksIndividualAggregatorLookUpIndividualData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


/**
   * Look up an individual in the aggregator.
   *
   * This returns the {@link Individual} with the given ``id`` if it exists in
   * the aggregator, and ``null`` otherwise.
   *
   * In future, when lazy-loading of individuals' properties is added to folks,
   * this method guarantees to load all properties of the individual, even if
   * the aggregator hasn't lazy-loaded anything else.
   *
   * This method is safe to call before {@link IndividualAggregator.prepare} has
   * been called, and will call {@link IndividualAggregator.prepare} itself in
   * that case.
   *
   * @param id ID of the individual to look up
   * @return individual with ``id``, or ``null`` if no such individual was found
   * @throws GLib.Error from {@link IndividualAggregator.prepare}
   *
   * @since 0.7.0
   */
static void folks_individual_aggregator_look_up_individual_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	FolksIndividualAggregatorLookUpIndividualData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	folks_individual_aggregator_look_up_individual_co (_data_);
}


static gboolean folks_individual_aggregator_look_up_individual_co (FolksIndividualAggregatorLookUpIndividualData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_state_ = 1;
	folks_individual_aggregator_prepare (_data_->self, folks_individual_aggregator_look_up_individual_ready, _data_);
	return FALSE;
	_state_1:
	folks_individual_aggregator_prepare_finish (_data_->self, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	_data_->_tmp0_ = _data_->self->priv->_individuals;
	_data_->_tmp1_ = _data_->id;
	_data_->_tmp2_ = NULL;
	_data_->_tmp2_ = gee_map_get (_data_->_tmp0_, _data_->_tmp1_);
	_data_->result = (FolksIndividual*) _data_->_tmp2_;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


gboolean folks_individual_aggregator_get_is_prepared (FolksIndividualAggregator* self) {
	gboolean result;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_is_prepared;
	result = _tmp0_;
	return result;
}


gboolean folks_individual_aggregator_get_is_quiescent (FolksIndividualAggregator* self) {
	gboolean result;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_is_quiescent;
	result = _tmp0_;
	return result;
}


FolksPersonaStore* folks_individual_aggregator_get_primary_store (FolksIndividualAggregator* self) {
	FolksPersonaStore* result;
	FolksPersonaStore* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_primary_store;
	result = _tmp0_;
	return result;
}


GeeMap* folks_individual_aggregator_get_individuals (FolksIndividualAggregator* self) {
	GeeMap* result;
	GeeMap* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_individuals_ro;
	result = _tmp0_;
	return result;
}


static void folks_individual_aggregator_set_individuals (FolksIndividualAggregator* self, GeeMap* value) {
	GeeMap* _tmp0_;
	GeeMap* _tmp1_;
	GeeMap* _tmp2_;
	GeeMap* _tmp3_;
	GeeMap* _tmp4_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = _g_object_ref0 (_tmp0_);
	_g_object_unref0 (self->priv->_individuals);
	self->priv->_individuals = _tmp1_;
	_tmp2_ = self->priv->_individuals;
	_tmp3_ = gee_map_get_read_only_view (_tmp2_);
	_tmp4_ = _tmp3_;
	_g_object_unref0 (self->priv->_individuals_ro);
	self->priv->_individuals_ro = _tmp4_;
	g_object_notify ((GObject *) self, "individuals");
}


FolksIndividual* folks_individual_aggregator_get_user (FolksIndividualAggregator* self) {
	FolksIndividual* result;
	FolksIndividual* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_user;
	result = _tmp0_;
	return result;
}


static void folks_individual_aggregator_set_user (FolksIndividualAggregator* self, FolksIndividual* value) {
	FolksIndividual* _tmp0_;
	FolksIndividual* _tmp1_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = _g_object_ref0 (_tmp0_);
	_g_object_unref0 (self->priv->_user);
	self->priv->_user = _tmp1_;
	g_object_notify ((GObject *) self, "user");
}


static void g_cclosure_user_marshal_VOID__OBJECT_OBJECT_STRING_OBJECT_ENUM (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
	typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING_OBJECT_ENUM) (gpointer data1, gpointer arg_1, gpointer arg_2, const char* arg_3, gpointer arg_4, gint arg_5, gpointer data2);
	register GMarshalFunc_VOID__OBJECT_OBJECT_STRING_OBJECT_ENUM callback;
	register GCClosure * cc;
	register gpointer data1;
	register gpointer data2;
	cc = (GCClosure *) closure;
	g_return_if_fail (n_param_values == 6);
	if (G_CCLOSURE_SWAP_DATA (closure)) {
		data1 = closure->data;
		data2 = param_values->data[0].v_pointer;
	} else {
		data1 = param_values->data[0].v_pointer;
		data2 = closure->data;
	}
	callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING_OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
	callback (data1, g_value_get_object (param_values + 1), g_value_get_object (param_values + 2), g_value_get_string (param_values + 3), g_value_get_object (param_values + 4), g_value_get_enum (param_values + 5), data2);
}


static gchar* string_strip (const gchar* self) {
	gchar* result = NULL;
	gchar* _tmp0_ = NULL;
	gchar* _result_;
	const gchar* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_strdup (self);
	_result_ = _tmp0_;
	_tmp1_ = _result_;
	g_strstrip (_tmp1_);
	result = _result_;
	return result;
}


static GObject * folks_individual_aggregator_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
	GObject * obj;
	GObjectClass * parent_class;
	FolksIndividualAggregator * self;
	GeeHashMap* _tmp0_;
	GeeHashMap* _tmp1_;
	GeeMap* _tmp2_;
	GeeMap* _tmp3_;
	GeeMap* _tmp4_;
	GeeHashMultiMap* _tmp5_;
	GeeHashSet* _tmp6_;
	FolksDebug* _tmp7_ = NULL;
	FolksDebug* _tmp8_;
	const gchar* _tmp9_ = NULL;
	gchar* _tmp10_;
	gchar* store_config_ids;
	const gchar* _tmp11_;
	const gchar* _tmp19_;
	const gchar* _tmp34_;
	const gchar* _tmp35_;
	const gchar* _tmp36_ = NULL;
	gchar* _tmp37_;
	gchar* disable_linking;
	const gchar* _tmp38_;
	gboolean _tmp43_ = FALSE;
	gboolean _tmp44_ = FALSE;
	const gchar* _tmp45_;
	gboolean _tmp47_;
	gboolean _tmp49_;
	FolksBackendStore* _tmp50_ = NULL;
	parent_class = G_OBJECT_CLASS (folks_individual_aggregator_parent_class);
	obj = parent_class->constructor (type, n_construct_properties, construct_properties);
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregator);
	_tmp0_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, FOLKS_TYPE_PERSONA_STORE, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL);
	_g_object_unref0 (self->priv->_stores);
	self->priv->_stores = _tmp0_;
	_tmp1_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL);
	_g_object_unref0 (self->priv->_individuals);
	self->priv->_individuals = (GeeMap*) _tmp1_;
	_tmp2_ = self->priv->_individuals;
	_tmp3_ = gee_map_get_read_only_view (_tmp2_);
	_tmp4_ = _tmp3_;
	_g_object_unref0 (self->priv->_individuals_ro);
	self->priv->_individuals_ro = _tmp4_;
	_tmp5_ = gee_hash_multi_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, FOLKS_TYPE_INDIVIDUAL, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL, NULL);
	_g_object_unref0 (self->priv->_link_map);
	self->priv->_link_map = _tmp5_;
	_tmp6_ = gee_hash_set_new (FOLKS_TYPE_BACKEND, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
	_g_object_unref0 (self->priv->_backends);
	self->priv->_backends = _tmp6_;
	_tmp7_ = folks_debug_dup ();
	_g_object_unref0 (self->priv->_debug);
	self->priv->_debug = _tmp7_;
	_tmp8_ = self->priv->_debug;
	g_signal_connect_object (_tmp8_, "print-status", (GCallback) __folks_individual_aggregator_debug_print_status_folks_debug_print_status, self, 0);
	_tmp9_ = g_getenv ("FOLKS_PRIMARY_STORE");
	_tmp10_ = g_strdup (_tmp9_);
	store_config_ids = _tmp10_;
	_tmp11_ = store_config_ids;
	if (_tmp11_ == NULL) {
		const gchar* _tmp12_ = NULL;
		gchar* _tmp13_;
		const gchar* _tmp14_;
		_tmp12_ = g_getenv ("FOLKS_WRITEABLE_STORE");
		_tmp13_ = g_strdup (_tmp12_);
		_g_free0 (store_config_ids);
		store_config_ids = _tmp13_;
		_tmp14_ = store_config_ids;
		if (_tmp14_ != NULL) {
			gchar* _tmp15_;
			gchar* deprecated_warn;
			const gchar* _tmp16_;
			gchar* _tmp17_;
			const gchar* _tmp18_;
			_tmp15_ = g_strdup ("FOLKS_WRITEABLE_STORE is deprecated, ");
			deprecated_warn = _tmp15_;
			_tmp16_ = deprecated_warn;
			_tmp17_ = g_strconcat (_tmp16_, "use FOLKS_PRIMARY_STORE", NULL);
			_g_free0 (deprecated_warn);
			deprecated_warn = _tmp17_;
			_tmp18_ = deprecated_warn;
			g_warning ("individual-aggregator.vala:308: %s", _tmp18_);
			_g_free0 (deprecated_warn);
		}
	}
	_tmp19_ = store_config_ids;
	if (_tmp19_ != NULL) {
		const gchar* _tmp20_;
		g_debug ("individual-aggregator.vala:314: Setting primary store IDs from environ" \
"ment variable.");
		_tmp20_ = store_config_ids;
		_folks_individual_aggregator_configure_primary_store (self, (const gchar*) _tmp20_);
	} else {
		gboolean _tmp21_;
		GSettings* _tmp26_;
		GSettings* settings;
		GSettings* _tmp27_;
		gchar* _tmp28_ = NULL;
		gchar* val;
		gboolean _tmp29_ = FALSE;
		const gchar* _tmp30_;
		gboolean _tmp32_;
		g_debug ("individual-aggregator.vala:319: Setting primary store IDs to defaults.");
		_tmp21_ = HAVE_EDS;
		if (_tmp21_) {
			gchar* _tmp22_;
			gchar* _tmp23_;
			_tmp22_ = g_strdup ("eds");
			_g_free0 (self->priv->_configured_primary_store_type_id);
			self->priv->_configured_primary_store_type_id = _tmp22_;
			_tmp23_ = g_strdup ("system-address-book");
			_g_free0 (self->priv->_configured_primary_store_id);
			self->priv->_configured_primary_store_id = _tmp23_;
		} else {
			gchar* _tmp24_;
			gchar* _tmp25_;
			_tmp24_ = g_strdup ("key-file");
			_g_free0 (self->priv->_configured_primary_store_type_id);
			self->priv->_configured_primary_store_type_id = _tmp24_;
			_tmp25_ = g_strdup ("");
			_g_free0 (self->priv->_configured_primary_store_id);
			self->priv->_configured_primary_store_id = _tmp25_;
		}
		_tmp26_ = g_settings_new (FOLKS_INDIVIDUAL_AGGREGATOR__FOLKS_GSETTINGS_SCHEMA);
		settings = _tmp26_;
		_tmp27_ = settings;
		_tmp28_ = g_settings_get_string (_tmp27_, FOLKS_INDIVIDUAL_AGGREGATOR__PRIMARY_STORE_CONFIG_KEY);
		val = _tmp28_;
		_tmp30_ = val;
		if (_tmp30_ != NULL) {
			const gchar* _tmp31_;
			_tmp31_ = val;
			_tmp29_ = g_strcmp0 (_tmp31_, "") != 0;
		} else {
			_tmp29_ = FALSE;
		}
		_tmp32_ = _tmp29_;
		if (_tmp32_) {
			const gchar* _tmp33_;
			g_debug ("individual-aggregator.vala:335: Setting primary store IDs from GSettin" \
"gs.");
			_tmp33_ = val;
			_folks_individual_aggregator_configure_primary_store (self, (const gchar*) _tmp33_);
		}
		_g_free0 (val);
		_g_object_unref0 (settings);
	}
	_tmp34_ = self->priv->_configured_primary_store_type_id;
	_tmp35_ = self->priv->_configured_primary_store_id;
	g_debug ("individual-aggregator.vala:340: Primary store IDs are '%s' and '%s'.", _tmp34_, _tmp35_);
	_tmp36_ = g_getenv ("FOLKS_DISABLE_LINKING");
	_tmp37_ = g_strdup (_tmp36_);
	disable_linking = _tmp37_;
	_tmp38_ = disable_linking;
	if (_tmp38_ != NULL) {
		const gchar* _tmp39_;
		gchar* _tmp40_ = NULL;
		gchar* _tmp41_;
		gchar* _tmp42_ = NULL;
		_tmp39_ = disable_linking;
		_tmp40_ = string_strip ((const gchar*) _tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = g_utf8_strdown (_tmp41_, (gssize) (-1));
		_g_free0 (disable_linking);
		disable_linking = _tmp42_;
		_g_free0 (_tmp41_);
	}
	_tmp45_ = disable_linking;
	if (_tmp45_ == NULL) {
		_tmp44_ = TRUE;
	} else {
		const gchar* _tmp46_;
		_tmp46_ = disable_linking;
		_tmp44_ = g_strcmp0 (_tmp46_, "no") == 0;
	}
	_tmp47_ = _tmp44_;
	if (_tmp47_) {
		_tmp43_ = TRUE;
	} else {
		const gchar* _tmp48_;
		_tmp48_ = disable_linking;
		_tmp43_ = g_strcmp0 (_tmp48_, "0") == 0;
	}
	_tmp49_ = _tmp43_;
	self->priv->_linking_enabled = _tmp49_;
	_tmp50_ = folks_backend_store_dup ();
	_g_object_unref0 (self->priv->_backend_store);
	self->priv->_backend_store = _tmp50_;
	g_debug ("individual-aggregator.vala:352: Constructing IndividualAggregator %p", self);
	_g_free0 (disable_linking);
	_g_free0 (store_config_ids);
	return obj;
}


static void folks_individual_aggregator_class_init (FolksIndividualAggregatorClass * klass) {
	folks_individual_aggregator_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (FolksIndividualAggregatorPrivate));
	G_OBJECT_CLASS (klass)->get_property = _vala_folks_individual_aggregator_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_folks_individual_aggregator_set_property;
	G_OBJECT_CLASS (klass)->constructor = folks_individual_aggregator_constructor;
	G_OBJECT_CLASS (klass)->finalize = folks_individual_aggregator_finalize;
	/**
	   * Whether {@link IndividualAggregator.prepare} has successfully completed for
	   * this aggregator.
	   *
	   * @since 0.3.0
	   */
	g_object_class_install_property (G_OBJECT_CLASS (klass), FOLKS_INDIVIDUAL_AGGREGATOR_IS_PREPARED, g_param_spec_boolean ("is-prepared", "is-prepared", "is-prepared", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	/**
	   * Whether the aggregator has reached a quiescent state. This will happen at
	   * some point after {@link IndividualAggregator.prepare} has successfully
	   * completed for the aggregator. An aggregator is in a quiescent state when
	   * all the {@link PersonaStore}s listed by its backends have reached a
	   * quiescent state.
	   *
	   * It's guaranteed that this property's value will only ever change after
	   * {@link IndividualAggregator.is_prepared} has changed to ``true``.
	   *
	   * @since 0.6.2
	   */
	g_object_class_install_property (G_OBJECT_CLASS (klass), FOLKS_INDIVIDUAL_AGGREGATOR_IS_QUIESCENT, g_param_spec_boolean ("is-quiescent", "is-quiescent", "is-quiescent", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	/**
	   * Our configured primary (writeable) store.
	   *
	   * Which one to use is decided (in order or precedence)
	   * by:
	   *
	   * - the FOLKS_PRIMARY_STORE env var (mostly for debugging)
	   * - the GSettings key set in ``_PRIMARY_STORE_CONFIG_KEY`` (system set store)
	   * - going with the ``key-file`` or ``eds`` store as the fall-back option
	   *
	   * @since 0.5.0
	   */
	g_object_class_install_property (G_OBJECT_CLASS (klass), FOLKS_INDIVIDUAL_AGGREGATOR_PRIMARY_STORE, g_param_spec_object ("primary-store", "primary-store", "primary-store", FOLKS_TYPE_PERSONA_STORE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	/**
	   * A map from {@link Individual.id}s to their {@link Individual}s.
	   *
	   * This is the canonical set of {@link Individual}s provided by this
	   * IndividualAggregator.
	   *
	   * {@link Individual}s may be added or removed using
	   * {@link IndividualAggregator.add_persona_from_details} and
	   * {@link IndividualAggregator.remove_individual}, respectively.
	   *
	   * @since 0.5.1
	   */
	g_object_class_install_property (G_OBJECT_CLASS (klass), FOLKS_INDIVIDUAL_AGGREGATOR_INDIVIDUALS, g_param_spec_object ("individuals", "individuals", "individuals", GEE_TYPE_MAP, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	/**
	   * The {@link Individual} representing the user.
	   *
	   * If it exists, this holds the {@link Individual} who is the user: the
	   * {@link Individual} containing the {@link Persona}s who are the owners of
	   * the accounts for their respective backends.
	   *
	   * @since 0.3.0
	   */
	g_object_class_install_property (G_OBJECT_CLASS (klass), FOLKS_INDIVIDUAL_AGGREGATOR_USER, g_param_spec_object ("user", "user", "user", FOLKS_TYPE_INDIVIDUAL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	/**
	   * Emitted when one or more {@link Individual}s are added to or removed from
	   * the aggregator.
	   *
	   * If more information about the relationships between {@link Individual}s
	   * which have been linked and unlinked is needed, consider connecting to
	   * {@link IndividualAggregator.individuals_changed_detailed} instead, which is
	   * emitted at the same time as this signal.
	   *
	   * This will not be emitted until after {@link IndividualAggregator.prepare}
	   * has been called.
	   *
	   * @param added a list of {@link Individual}s which have been added
	   * @param removed a list of {@link Individual}s which have been removed
	   * @param message a string message from the backend, if any
	   * @param actor the {@link Persona} who made the change, if known
	   * @param reason the reason for the change
	   *
	   * @since 0.5.1
	   */
	g_signal_new ("individuals_changed", FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_OBJECT_STRING_OBJECT_ENUM, G_TYPE_NONE, 5, GEE_TYPE_SET, GEE_TYPE_SET, G_TYPE_STRING, FOLKS_TYPE_PERSONA, FOLKS_GROUP_DETAILS_TYPE_CHANGE_REASON);
	/**
	   * Emitted when one or more {@link Individual}s are added to or removed from
	   * the aggregator.
	   *
	   * This is emitted at the same time as
	   * {@link IndividualAggregator.individuals_changed}, but includes more
	   * information about the relationships between {@link Individual}s which have
	   * been linked and unlinked.
	   *
	   * Individuals which have been linked will be listed in the multi-map as
	   * mappings from the old individuals to the single new individual which
	   * replaces them (i.e. each of the old individuals will map to the same new
	   * individual). This new individual is the one which will be specified as the
	   * ``replacement_individual`` in the {@link Individual.removed} signal for the
	   * old individuals.
	   *
	   * Individuals which have been unlinked will be listed in the multi-map as
	   * a mapping from the unlinked individual to a set of one or more individuals
	   * which replace it.
	   *
	   * Individuals which have been added will be listed in the multi-map as a
	   * mapping from ``null`` to the set of added individuals. If ``null`` doesn't
	   * map to anything, no individuals have been added to the aggregator.
	   *
	   * Individuals which have been removed will be listed in the multi-map as
	   * mappings from the removed individual to ``null``.
	   *
	   * This will not be emitted until after {@link IndividualAggregator.prepare}
	   * has been called.
	   *
	   * @param changes a mapping of old {@link Individual}s to new
	   * {@link Individual}s for the individuals which have changed in the
	   * aggregator
	   *
	   * @since 0.6.2
	   */
	g_signal_new ("individuals_changed_detailed", FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GEE_TYPE_MULTI_MAP);
}


static void folks_individual_aggregator_instance_init (FolksIndividualAggregator * self) {
	self->priv = FOLKS_INDIVIDUAL_AGGREGATOR_GET_PRIVATE (self);
	self->priv->_primary_store = NULL;
	self->priv->_linking_enabled = TRUE;
	g_static_rec_mutex_init (&self->priv->__lock__is_prepared);
	self->priv->_is_prepared = FALSE;
	self->priv->_prepare_pending = FALSE;
	self->priv->_non_quiescent_persona_store_count = (guint) 0;
	self->priv->_non_quiescent_backend_count = (guint) 0;
	self->priv->_is_quiescent = FALSE;
	self->priv->_quiescent_timeout_id = (guint) 0;
	self->priv->_user_configured_primary_store = FALSE;
}


static void folks_individual_aggregator_finalize (GObject* obj) {
	FolksIndividualAggregator * self;
	guint _tmp0_;
	FolksBackendStore* _tmp2_;
	guint _tmp3_ = 0U;
	FolksDebug* _tmp4_;
	guint _tmp5_ = 0U;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregator);
	g_debug ("individual-aggregator.vala:357: Destroying IndividualAggregator %p", self);
	_tmp0_ = self->priv->_quiescent_timeout_id;
	if (_tmp0_ != ((guint) 0)) {
		guint _tmp1_;
		_tmp1_ = self->priv->_quiescent_timeout_id;
		g_source_remove (_tmp1_);
		self->priv->_quiescent_timeout_id = (guint) 0;
	}
	_tmp2_ = self->priv->_backend_store;
	g_signal_parse_name ("backend-available", FOLKS_TYPE_BACKEND_STORE, &_tmp3_, NULL, FALSE);
	g_signal_handlers_disconnect_matched (_tmp2_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __folks_individual_aggregator_backend_available_cb_folks_backend_store_backend_available, self);
	_tmp4_ = self->priv->_debug;
	g_signal_parse_name ("print-status", FOLKS_TYPE_DEBUG, &_tmp5_, NULL, FALSE);
	g_signal_handlers_disconnect_matched (_tmp4_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp5_, 0, NULL, (GCallback) __folks_individual_aggregator_debug_print_status_folks_debug_print_status, self);
	_g_object_unref0 (self->priv->_backend_store);
	_g_object_unref0 (self->priv->_stores);
	_g_object_unref0 (self->priv->_backends);
	_g_object_unref0 (self->priv->_link_map);
	g_static_rec_mutex_free (&self->priv->__lock__is_prepared);
	_g_object_unref0 (self->priv->_debug);
	_g_free0 (self->priv->_configured_primary_store_type_id);
	_g_free0 (self->priv->_configured_primary_store_id);
	_g_object_unref0 (self->priv->_individuals);
	_g_object_unref0 (self->priv->_individuals_ro);
	_g_object_unref0 (self->priv->_user);
	G_OBJECT_CLASS (folks_individual_aggregator_parent_class)->finalize (obj);
}


/**
 * Stores {@link Individual}s which have been created through
 * aggregation of all the {@link Persona}s provided by the various
 * {@link Backend}s.
 *
 * This is the main interface for client applications.
 */
GType folks_individual_aggregator_get_type (void) {
	static volatile gsize folks_individual_aggregator_type_id__volatile = 0;
	if (g_once_init_enter (&folks_individual_aggregator_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (FolksIndividualAggregatorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) folks_individual_aggregator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (FolksIndividualAggregator), 0, (GInstanceInitFunc) folks_individual_aggregator_instance_init, NULL };
		GType folks_individual_aggregator_type_id;
		folks_individual_aggregator_type_id = g_type_register_static (G_TYPE_OBJECT, "FolksIndividualAggregator", &g_define_type_info, 0);
		g_once_init_leave (&folks_individual_aggregator_type_id__volatile, folks_individual_aggregator_type_id);
	}
	return folks_individual_aggregator_type_id__volatile;
}


static void _vala_folks_individual_aggregator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	FolksIndividualAggregator * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregator);
	switch (property_id) {
		case FOLKS_INDIVIDUAL_AGGREGATOR_IS_PREPARED:
		g_value_set_boolean (value, folks_individual_aggregator_get_is_prepared (self));
		break;
		case FOLKS_INDIVIDUAL_AGGREGATOR_IS_QUIESCENT:
		g_value_set_boolean (value, folks_individual_aggregator_get_is_quiescent (self));
		break;
		case FOLKS_INDIVIDUAL_AGGREGATOR_PRIMARY_STORE:
		g_value_set_object (value, folks_individual_aggregator_get_primary_store (self));
		break;
		case FOLKS_INDIVIDUAL_AGGREGATOR_INDIVIDUALS:
		g_value_set_object (value, folks_individual_aggregator_get_individuals (self));
		break;
		case FOLKS_INDIVIDUAL_AGGREGATOR_USER:
		g_value_set_object (value, folks_individual_aggregator_get_user (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void _vala_folks_individual_aggregator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
	FolksIndividualAggregator * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, FOLKS_TYPE_INDIVIDUAL_AGGREGATOR, FolksIndividualAggregator);
	switch (property_id) {
		case FOLKS_INDIVIDUAL_AGGREGATOR_INDIVIDUALS:
		folks_individual_aggregator_set_individuals (self, g_value_get_object (value));
		break;
		case FOLKS_INDIVIDUAL_AGGREGATOR_USER:
		folks_individual_aggregator_set_user (self, g_value_get_object (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}


static gint _vala_array_length (gpointer array) {
	int length;
	length = 0;
	if (array) {
		while (((gpointer*) array)[length]) {
			length++;
		}
	}
	return length;
}



