~ubuntu-branches/ubuntu/quantal/folks/quantal

 * generated from individual-aggregator.vala, do not modify */

 

/*

typedef struct _FolksPotentialMatch FolksPotentialMatch;

typedef struct _FolksPotentialMatchClass FolksPotentialMatchClass;

typedef struct _FolksIndividualAggregatorAddBackendData FolksIndividualAggregatorAddBackendData;

 

#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)))

 

#define FOLKS_TYPE_PERSONA_STORE_TRUST (folks_persona_store_trust_get_type ())

 

#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))

 

typedef struct _FolksAntiLinkable FolksAntiLinkable;

typedef struct _FolksAntiLinkableIface FolksAntiLinkableIface;

#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))

typedef struct _FolksIndividualAggregatorAddPersonaFromDetailsData FolksIndividualAggregatorAddPersonaFromDetailsData;

typedef struct _FolksIndividualAggregatorRemoveIndividualData FolksIndividualAggregatorRemoveIndividualData;

typedef struct _FolksIndividualAggregatorRemovePersonaData FolksIndividualAggregatorRemovePersonaData;

typedef struct _FolksIndividualAggregatorLinkPersonasData FolksIndividualAggregatorLinkPersonasData;

        FolksPersonaStore* _tmp20_;

};

 

        int _ref_count_;

        FolksIndividualAggregator * self;

        gchar* store_id;

        FOLKS_GROUP_DETAILS_CHANGE_REASON_SEPARATED = 11

} FolksGroupDetailsChangeReason;

 

        int _ref_count_;

        FolksIndividualAggregator * self;

        FolksPersona* persona;

        FOLKS_PERSONA_STORE_TRUST_FULL

} FolksPersonaStoreTrust;

 

        int _ref_count_;

        const gchar* prop_name;

};

 

typedef enum  {

        FOLKS_PROPERTY_ERROR_NOT_WRITEABLE,

        FOLKS_PROPERTY_ERROR_INVALID_VALUE,

} FolksPropertyError;

#define FOLKS_PROPERTY_ERROR folks_property_error_quark ()

struct _FolksAntiLinkableIface {

        void (*set_anti_links) (FolksAntiLinkable* self, GeeSet* value);

};

 

        int _ref_count_;

        FolksIndividualAggregator * self;

        FolksIndividual* individual;

        GError * _inner_error_;

};

 

        int _ref_count_;

        FolksIndividualAggregator * self;

        GHashTable* retval;

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);

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);

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 _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_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);

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);

void folks_persona_linkable_property_to_links (FolksPersona* self, const gchar* prop_name, FolksPersonaLinkablePropertyCallback callback, void* callback_target);

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);

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 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);

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 void _g_free0_ (gpointer var);

static void _vala_GValue_free (GValue* self);

static void __vala_GValue_free0_ (gpointer var);

static GValue* _g_value_dup (GValue* 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);

   * @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

   * if no matches could be found, an empty map is returned

   *

   * @since 0.5.1

   * @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

   *

   * @since 0.5.1

   */

        _data_->self = _tmp0_;

        _tmp1_ = backend;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->backend = _tmp2_;

        _folks_individual_aggregator_add_backend_co (_data_);

}

}

 

 

}

 

 

                FolksIndividualAggregator * self;

                _g_object_unref0 (self);

        }

}

 

}

 

 

        FolksIndividualAggregator * self;

        GError * _inner_error_ = NULL;

        g_return_if_fail (_result_ != NULL);

        {

                FolksPersonaStore* _tmp0_;

                GAsyncResult* _tmp1_;

                _tmp1_ = _result_;

                folks_persona_store_prepare_finish (_tmp0_, _tmp1_, &_inner_error_);

                if (_inner_error_ != NULL) {

                e = _inner_error_;

                _inner_error_ = NULL;

                _tmp2_ = _ ("Error preparing persona store '%s': %s");

                _tmp4_ = e;

                _tmp5_ = _tmp4_->message;

                g_warning (_tmp2_, _tmp3_, _tmp5_);

}

 

 

}

 

 

static void _folks_individual_aggregator_backend_persona_store_added_cb (FolksIndividualAggregator* self, FolksBackend* backend, FolksPersonaStore* store) {

        FolksPersonaStore* _tmp0_;

        FolksPersonaStore* _tmp1_;

        FolksBackend* _tmp2_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (backend != NULL);

        g_return_if_fail (store != NULL);

        _tmp0_ = store;

        _tmp1_ = _g_object_ref0 (_tmp0_);

        _tmp2_ = backend;

        _tmp3_ = folks_backend_get_name (_tmp2_);

        _tmp4_ = _tmp3_;

        _tmp6_ = folks_persona_store_get_id (_tmp5_);

        _tmp7_ = _tmp6_;

        g_debug ("individual-aggregator.vala:799: _backend_persona_store_added_cb(): bac" \

"kend: %s, store: %s (%p)", _tmp4_, _tmp7_, _tmp8_);

        _tmp10_ = folks_persona_store_get_type_id (_tmp9_);

        _tmp11_ = _tmp10_;

        _tmp13_ = folks_persona_store_get_id (_tmp12_);

        _tmp14_ = _tmp13_;

        _tmp15_ = _folks_individual_aggregator_get_store_full_id (self, _tmp11_, _tmp14_);

        _folks_individual_aggregator_maybe_configure_as_primary (self, _tmp16_);

        _folks_individual_aggregator_set_primary_store (self, _tmp17_);

        _tmp18_ = self->priv->_stores;

        gee_abstract_map_set ((GeeAbstractMap*) _tmp18_, _tmp19_, _tmp20_);

        g_signal_connect_object (_tmp21_, "personas-changed", (GCallback) __folks_individual_aggregator_personas_changed_cb_folks_persona_store_personas_changed, self, 0);

        g_signal_connect_object ((GObject*) _tmp22_, "notify::is-primary-store", (GCallback) __folks_individual_aggregator_is_primary_store_changed_cb_g_object_notify, self, 0);

        g_signal_connect_object ((GObject*) _tmp23_, "notify::is-quiescent", (GCallback) __folks_individual_aggregator_persona_store_is_quiescent_changed_cb_g_object_notify, self, 0);

        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);

        _tmp26_ = folks_persona_store_get_is_quiescent (_tmp25_);

        _tmp27_ = _tmp26_;

        if (_tmp27_ == FALSE) {

                        self->priv->_quiescent_timeout_id = _tmp30_;

                }

        }

        _tmp32_ = folks_persona_store_get_personas (_tmp31_);

        _tmp33_ = _tmp32_;

        _tmp34_ = gee_map_get_size (_tmp33_);

                        GeeIterator* _tmp43_ = NULL;

                        GeeIterator* _tmp44_;

                        GeeIterator* _p_it;

                        _tmp38_ = folks_persona_store_get_personas (_tmp37_);

                        _tmp39_ = _tmp38_;

                        _tmp40_ = gee_map_get_values (_tmp39_);

                        }

                        _g_object_unref0 (_p_it);

                }

                _tmp52_ = persona_set;

                _tmp53_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);

                _tmp54_ = _tmp53_;

                _g_object_unref0 (_tmp54_);

                _g_object_unref0 (persona_set);

        }

}

 

 

}

 

 

static Block5Data* block5_data_ref (Block5Data* _data5_) {

        g_atomic_int_inc (&_data5_->_ref_count_);

        return _data5_;

        _data5_ = (Block5Data*) _userdata_;

        if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {

                FolksIndividualAggregator * self;

                g_slice_free (Block5Data, _data5_);

        }

}

 

 

        FolksIndividualAggregator * self;

        const gchar* _tmp0_;

        const gchar* prop_linking_value;

        GeeCollection* _tmp3_ = NULL;

        GeeCollection* candidate_ind_set;

        GeeCollection* _tmp4_;

        g_return_if_fail (l != NULL);

        _tmp0_ = l;

        prop_linking_value = _tmp0_;

                                        FolksPersona* _tmp20_;

                                        gboolean _tmp21_ = FALSE;

                                        _tmp19_ = candidate_ind;

                                        _tmp21_ = folks_individual_has_anti_link_with_persona (G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), _tmp20_);

                                        _tmp12_ = _tmp21_ == FALSE;

                                } else {

                                        GeeHashSet* _tmp23_;

                                        FolksIndividual* _tmp24_;

                                        gboolean _tmp25_ = FALSE;

                                        _tmp24_ = candidate_ind;

                                        _tmp25_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp23_, G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));

                                        _tmp11_ = _tmp25_;

                                        _tmp27_ = candidate_ind;

                                        _tmp28_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp27_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));

                                        _tmp29_ = _tmp28_;

                                        _tmp31_ = prop_linking_value;

                                        g_debug ("    Found candidate individual '%s'" " by linkable property '%s' = '%s'.", _tmp29_, _tmp30_, _tmp31_);

                                }

}

 

 

}

 

 

                _tmp1_ = gee_iterable_iterator ((GeeIterable*) _tmp0_);

                _persona_it = _tmp1_;

                while (TRUE) {

                        GeeIterator* _tmp2_;

                        gboolean _tmp3_ = FALSE;

                        GeeIterator* _tmp4_;

                        FolksIndividual* _tmp178_;

                        gboolean _tmp179_;

                        gboolean _tmp180_;

                        _tmp2_ = _persona_it;

                        _tmp3_ = gee_iterator_next (_tmp2_);

                        if (!_tmp3_) {

                                break;

                        }

                        _tmp4_ = _persona_it;

                        _tmp5_ = gee_iterator_get (_tmp4_);

                        _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);

                        _tmp12_ = gee_hash_set_new (FOLKS_TYPE_PERSONA, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);

                        final_personas = _tmp12_;

                        _tmp14_ = folks_persona_get_uid (_tmp13_);

                        _tmp15_ = _tmp14_;

                        _tmp17_ = folks_persona_get_iid (_tmp16_);

                        _tmp18_ = _tmp17_;

                        g_debug ("individual-aggregator.vala:1018: Aggregating persona '%s' on '%s'.", _tmp15_, _tmp18_);

                        _tmp22_ = folks_persona_get_is_user (_tmp21_);

                        _tmp23_ = _tmp22_;

                        if (_tmp23_ == TRUE) {

                                FolksPersona* _tmp27_;

                                gboolean _tmp28_ = FALSE;

                                _tmp26_ = *user;

                                _tmp28_ = folks_individual_has_anti_link_with_persona (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), _tmp27_);

                                _tmp19_ = _tmp28_ == FALSE;

                        } else {

                                _tmp32_ = _tmp31_;

                                g_debug ("individual-aggregator.vala:1025:     Found candidate individual '%s' a" \

"s user.", _tmp32_);

                                _tmp34_ = *user;

                                gee_abstract_collection_add ((GeeAbstractCollection*) _tmp33_, G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));

                        }

                                GeeCollection* candidate_ind_set;

                                GeeCollection* _tmp41_;

                                _tmp36_ = self->priv->_link_map;

                                _tmp38_ = folks_persona_get_iid (_tmp37_);

                                _tmp39_ = _tmp38_;

                                _tmp40_ = gee_multi_map_get ((GeeMultiMap*) _tmp36_, _tmp39_);

                                                                FolksPersona* _tmp57_;

                                                                gboolean _tmp58_ = FALSE;

                                                                _tmp56_ = candidate_ind;

                                                                _tmp58_ = folks_individual_has_anti_link_with_persona (G_TYPE_CHECK_INSTANCE_CAST (_tmp56_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual), _tmp57_);

                                                                _tmp49_ = _tmp58_ == FALSE;

                                                        } else {

                                                                GeeHashSet* _tmp60_;

                                                                FolksIndividual* _tmp61_;

                                                                gboolean _tmp62_ = FALSE;

                                                                _tmp61_ = candidate_ind;

                                                                _tmp62_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp60_, G_TYPE_CHECK_INSTANCE_CAST (_tmp61_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));

                                                                _tmp48_ = _tmp62_;

                                                                _tmp64_ = candidate_ind;

                                                                _tmp65_ = folks_individual_get_id (G_TYPE_CHECK_INSTANCE_CAST (_tmp64_, FOLKS_TYPE_INDIVIDUAL, FolksIndividual));

                                                                _tmp66_ = _tmp65_;

                                                                _tmp68_ = folks_persona_get_iid (_tmp67_);

                                                                _tmp69_ = _tmp68_;

                                                                g_debug ("    Found candidate individual '%s' by " "IID '%s'.", _tmp66_, _tmp69_);

                                }

                                _g_object_unref0 (candidate_ind_set);

                        }

                        _tmp71_ = folks_persona_get_store (_tmp70_);

                        _tmp72_ = _tmp71_;

                        _tmp73_ = folks_persona_store_get_trust_level (_tmp72_);

                                gint _tmp76__length1;

                                gchar** _tmp77_;

                                gint _tmp77__length1;

                                _tmp76_ = folks_persona_get_linkable_properties (_tmp75_, &_tmp76__length1);

                                _tmp77_ = _tmp76_;

                                _tmp77__length1 = _tmp76__length1;

                                                const gchar* foo = NULL;

                                                foo = foo_collection[foo_it];

                                                {

                                                        const gchar* _tmp78_;

                                                        FolksPersona* _tmp79_;

                                                        GObjectClass* _tmp80_ = NULL;

                                                        GParamSpec* _tmp83_ = NULL;

                                                        FolksPersona* _tmp86_;

                                                        const gchar* _tmp87_;

                                                        _tmp78_ = foo;

                                                        _tmp80_ = G_OBJECT_GET_CLASS ((GObject*) _tmp79_);

                                                        pclass = _tmp80_;

                                                        _tmp81_ = pclass;

                                                        _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.");

                                                                g_warning (_tmp84_, _tmp85_);

                                                                continue;

                                                        }

                                                }

                                        }

                                }

                        }

                        _tmp88_ = final_personas;

                        gee_abstract_collection_add ((GeeAbstractCollection*) _tmp88_, _tmp89_);

                        _tmp92_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp91_);

                        _tmp93_ = _tmp92_;

                        if (_tmp93_ > 0) {

                                        GeeHashSet* _tmp96_;

                                        GeeIterator* _tmp97_ = NULL;

                                        GeeIterator* _individual_it;

                                        _tmp97_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp96_);

                                        _individual_it = _tmp97_;

                                        while (TRUE) {

                                GeeHashSet* _tmp106_;

                                gint _tmp107_;

                                gint _tmp108_;

                                _tmp107_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp106_);

                                _tmp108_ = _tmp107_;

                                if (_tmp108_ > 0) {

                                GeeHashSet* _tmp127_;

                                GeeIterator* _tmp128_ = NULL;

                                GeeIterator* _i_it;

                                _tmp128_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) _tmp127_);

                                _i_it = _tmp128_;

                                while (TRUE) {

                        }

                        _g_object_unref0 (final_individual);

                        _g_object_unref0 (final_personas);

                }

                _g_object_unref0 (_persona_it);

        }

}

 

 

}

 

 

                FolksIndividualAggregator * self;

                _g_object_unref0 (self);

        }

}

 

 

        FolksIndividualAggregator * self;

        const gchar* _tmp0_;

        const gchar* prop_linking_value;

        GeeHashMultiMap* _tmp1_;

        FolksIndividual* _tmp2_;

        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;

        gee_multi_map_set ((GeeMultiMap*) _tmp1_, prop_linking_value, _tmp2_);

}

 

 

}

 

 

static void _folks_individual_aggregator_add_persona_to_link_map (FolksIndividualAggregator* self, FolksPersona* persona, FolksIndividual* individual) {

        FolksIndividual* _tmp0_;

        FolksIndividual* _tmp1_;

        const gchar* _tmp2_ = NULL;

        g_return_if_fail (self != NULL);

        g_return_if_fail (persona != NULL);

        g_return_if_fail (individual != NULL);

        _tmp0_ = individual;

        _tmp1_ = _g_object_ref0 (_tmp0_);

        _tmp3_ = persona;

        _tmp4_ = folks_persona_get_is_user (_tmp3_);

        _tmp5_ = _tmp4_;

        _tmp12_ = _tmp11_;

        g_debug ("individual-aggregator.vala:1268: Connecting to Persona: %s (is user: %" \

"s, IID: %s)", _tmp8_, _tmp9_, _tmp12_);

        _tmp14_ = folks_individual_get_id (_tmp13_);

        _tmp15_ = _tmp14_;

        g_debug ("individual-aggregator.vala:1270:     Mapping to Individual: %s", _tmp15_);

        _tmp17_ = persona;

        _tmp18_ = folks_persona_get_iid (_tmp17_);

        _tmp19_ = _tmp18_;

        gee_multi_map_set ((GeeMultiMap*) _tmp16_, _tmp19_, _tmp20_);

        _tmp21_ = persona;

        _tmp22_ = folks_persona_get_store (_tmp21_);

                                        }

                                        _tmp37_ = persona;

                                        _tmp38_ = prop_name;

                                }

                        }

                }

        }

}

 

 

        _data_->self = _tmp0_;

        _tmp1_ = parent;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->parent = _tmp2_;

        _tmp3_ = persona_store;

        _tmp4_ = _g_object_ref0 (_tmp3_);

        _data_->persona_store = _tmp4_;

        _tmp5_ = details;

        _tmp6_ = _g_hash_table_ref0 (_tmp5_);

        _data_->details = _tmp6_;

        folks_individual_aggregator_add_persona_from_details_co (_data_);

}

 

 

/**

   *

   * If the target store is offline, this function will throw

   * {@link IndividualAggregatorError.STORE_OFFLINE}. It's the responsibility of

   *  * 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

   *

   * @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}

   * will also be added to a new or existing {@link Individual} as necessary.

   * @throws IndividualAggregatorError.STORE_OFFLINE if the persona store was

   * offline

}

 

 

}

 

 

                FolksIndividualAggregator * self;

                _g_object_unref0 (self);

        }

}

 

}

 

 

        FolksIndividualAggregator * self;

        const gchar* _tmp0_;

        gchar* _tmp1_;

        GValue* _tmp2_;

        GValue* _tmp3_;

        g_return_if_fail (k != NULL);

        _tmp0_ = k;

        _tmp1_ = g_strdup ((const gchar*) _tmp0_);

        _tmp2_ = v;

        _tmp3_ = __g_value_dup0 (_tmp2_);

}

 

 

}

 

 

static GHashTable* _folks_individual_aggregator_asv_copy (FolksIndividualAggregator* self, GHashTable* asv) {

        GHashTable* result = NULL;

        GHashFunc _tmp0_;

        GEqualFunc _tmp1_;

        GHashTable* _tmp2_;

        GHashTable* _tmp4_;

        g_return_val_if_fail (self != NULL, NULL);

        g_return_val_if_fail (asv != NULL, NULL);

        _tmp0_ = g_str_hash;

        _tmp1_ = g_str_equal;

        _tmp2_ = g_hash_table_new_full (_tmp0_, _tmp1_, _g_free0_, __vala_GValue_free0_);

        _tmp3_ = asv;

        result = _tmp4_;

        return result;

}

 

        _data_->self = _tmp0_;

        _tmp1_ = individual;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->individual = _tmp2_;

        folks_individual_aggregator_remove_individual_co (_data_);

}

        _data_->self = _tmp0_;

        _tmp1_ = persona;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->persona = _tmp2_;

        folks_individual_aggregator_remove_persona_co (_data_);

}

        _data_->self = _tmp0_;

        _tmp1_ = personas;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->personas = _tmp2_;

        folks_individual_aggregator_link_personas_co (_data_);

}

        _data_->self = _tmp0_;

        _tmp1_ = individual;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->individual = _tmp2_;

        folks_individual_aggregator_unlink_individual_co (_data_);

}

        _data_->self = _tmp0_;

        _tmp1_ = individual;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->individual = _tmp2_;

        _tmp3_ = property_name;

        _tmp4_ = g_strdup (_tmp3_);

        _data_->property_name = _tmp4_;

        folks_individual_aggregator_ensure_individual_property_writeable_co (_data_);

}

   * {@link Individual}.

   *

   * This makes sure that there is at least one {@link Persona} in the

   * {@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

   * {@link IndividualAggregatorError.PROPERTY_NOT_WRITEABLE} error will be

   * thrown.

   *

   * 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”)

   * @throws IndividualAggregatorError.NO_PRIMARY_STORE if no primary store was

   * configured for this individual aggregator

   * @throws IndividualAggregatorError.PROPERTY_NOT_WRITEABLE if the given

   * @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

        _data_->self = _tmp0_;

        _tmp1_ = personas;

        _tmp2_ = _g_object_ref0 (_tmp1_);

        _data_->personas = _tmp2_;

        _tmp3_ = property_name;

        _tmp4_ = g_strdup (_tmp3_);

        _data_->property_name = _tmp4_;

        _folks_individual_aggregator_ensure_personas_property_writeable_co (_data_);

}

        _data_->self = _tmp0_;

        _tmp1_ = id;

        _tmp2_ = g_strdup (_tmp1_);

        _data_->id = _tmp2_;

        folks_individual_aggregator_look_up_individual_co (_data_);

}

/**

   * Look up an individual in the aggregator.

   *

   *

   * In future, when lazy-loading of individuals' properties is added to folks,

   * this method guarantees to load all properties of the individual, even if

   * that case.

   *

   * @param id ID of the individual to look up

   * @throws GLib.Error from {@link IndividualAggregator.prepare}

   *

   * @since 0.7.0

           * quiescent state.

           *

           * It's guaranteed that this property's value will only ever change after

           *

           * @since 0.6.2

           */

           * by:

           *

           * - the FOLKS_PRIMARY_STORE env var (mostly for debugging)

           *

           * @since 0.5.0

           */

           * 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

           * old individuals.

           *

           * Individuals which have been unlinked will be listed in the multi-map as

           * which replace it.

           *

           * Individuals which have been added will be listed in the multi-map as a

           * map to anything, no individuals have been added to the aggregator.

           *

           * Individuals which have been removed will be listed in the multi-map as

           *

           * This will not be emitted until after {@link IndividualAggregator.prepare}

           * has been called.