lasso-2.7.0/lasso/registry.c

/* $Id$
 *
 * Lasso - A free implementation of the Liberty Alliance specifications.
 *
 * Copyright (C) 2004-2007 Entr'ouvert
 * http://lasso.entrouvert.org
 *
 * Authors: See AUTHORS file in top-level directory.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <glib.h>
#include "registry-private.h"
#include "errors.h"
#include "utils.h"


/**
 * SECTION:registry
 * @short_description: Class to store a mapping of qualified names (QName) to other qualified names.
 *
 * A qualified name is a name or a string in the context of another name, or namespace.
 * This object implement a function of a tuple (namespace, name, namespace) to a name.  For the
 * moment there is no need to enumerate all tuples (namespace, name) pair given a base pair, i.e. a
 * function from tuple (namespace, name) to a list of tuples (namespace,name).
 *
 * We support two kinds of mapping:
 * <itemizedlist>
 * <listitem><para>you can give a direct mapping between two QName,</para></listitem>
 * <listitem><para>or you can give a function that will manage mapping between one namespace and
 * another one.</para></listitem>
 * </itemizedlist>
 *
 * For internal use inside lasso we define the following namespaces:
 * <itemizedlist>
 * <listitem><para>#LASSO_LASSO_HREF and,</para></listitem>
 * <listitem><para>#LASSO_PYTHON_HREF.</para></listitem>
 * </itemizedlist>
 *
 * For functional mappings the mapping function must return constant strings created using
 * g_intern_string() or using g_type_name().
 */

typedef struct _LassoRegistryDirectMappingRecord LassoRegistryDirectMappingRecord;

struct _LassoRegistryDirectMappingRecord {
	GQuark from_namespace;
	GQuark from_name;
	GQuark to_namespace;
	GQuark to_name;
};

typedef struct _LassoRegistryFunctionalMappingRecord LassoRegistryFunctionalMappingRecord;

struct _LassoRegistryFunctionalMappingRecord {
	GQuark from_namespace;
	GQuark to_namespace;
	LassoRegistryTranslationFunction translation_function;
};

static LassoRegistry *default_registry = NULL;

static LassoRegistry *lasso_registry_get_default() {
	if (default_registry == NULL) {
		default_registry = lasso_registry_new();
	}
	return default_registry;
}

void lasso_registry_default_shutdown()
{
	if (default_registry)
		lasso_registry_destroy(default_registry);
	default_registry = NULL;
}

/**
 * lasso_registry_direct_mapping_equal:
 * @record1: left record
 * @record2: right record
 *
 * Tests if two #LassoRegistryDirectMappingRecord are equal.
 *
 * Return value: TRUE if all field of record1 are equal to record2.
 */
gboolean lasso_registry_direct_mapping_equal(LassoRegistryDirectMappingRecord *record1,
		LassoRegistryDirectMappingRecord *record2)
{
	return record1->from_namespace == record2->from_namespace
		&& record1->from_name == record2->from_name
		&& record1->to_namespace == record2->to_namespace;
}

/**
 * lasso_registry_functional_mapping_equal:
 * @record1: left record
 * @record2: right record
 *
 * Tests if two #LassoRegistryFunctionalMappingRecord are equal, i.e.  if they are functional
 * mapping between the same namespace.
 *
 * Return value: TRUE if record1 is equal to record2
 */
gboolean lasso_registry_functional_mapping_equal(LassoRegistryFunctionalMappingRecord *record1,
		LassoRegistryFunctionalMappingRecord *record2)
{
	return record1->from_namespace == record2->from_namespace &&
		record1->to_namespace == record2->to_namespace;
}

/**
 * lasso_registry_direct_mapping_hash:
 * @record: a #LassoRegistryDirectMappingRecord structure
 *
 * Return a hash value obtained from the three first fields of a #LassoRecordRegistry structure.
 *
 * Return value: an integer hash for the record.
 */
guint lasso_registry_direct_mapping_hash(LassoRegistryDirectMappingRecord *record)
{
	return g_direct_hash((gpointer)((ptrdiff_t)record->from_namespace
		^ (ptrdiff_t)record->from_name
		^ (ptrdiff_t)record->to_namespace));
}

/**
 * lasso_registry_functional_mapping_hash:
 * @record: a #LassoRegistryFunctionalMappingRecord structure
 *
 * Return a hash value obtained from the source and destination namespace of the mapping.
 *
 * Return value: an integer hash for the record.
 */
guint lasso_registry_functional_mapping_hash(LassoRegistryFunctionalMappingRecord *record)
{
	return g_direct_hash((gpointer)((ptrdiff_t)record->from_namespace
				^ (ptrdiff_t)record->to_namespace));
}

/**
 * lasso_registry_new:
 *
 * Allocate a new #LassoRegistry structure and initialize its fields.
 *
 * Return value: a newly allocated #LassoRegistry object.
 */
LassoRegistry *lasso_registry_new()
{
	LassoRegistry *ret = g_new0(LassoRegistry, 1);

	ret->direct_mapping = g_hash_table_new_full(
			(GHashFunc) lasso_registry_direct_mapping_hash,
			(GEqualFunc) lasso_registry_direct_mapping_equal,
			NULL,
			g_free);

	ret->functional_mapping = g_hash_table_new_full(
			(GHashFunc) lasso_registry_functional_mapping_hash,
			(GEqualFunc) lasso_registry_functional_mapping_equal,
			NULL,
			g_free);

	return ret;
}

/**
 * lasso_registry_destroy:
 * @registry: the #LassoRegistry object
 *
 * Destroy a #LassoRegistry.
 */
void lasso_registry_destroy(LassoRegistry *registry)
{
	g_return_if_fail(registry);

	lasso_release_ghashtable(registry->direct_mapping);
	lasso_release_ghashtable(registry->functional_mapping);
	lasso_release(registry);
}

static LassoRegistryTranslationFunction lasso_registry_get_translation_function(GHashTable *functional_mappings, GQuark from_ns_quark, GQuark to_ns_quark)
{
		LassoRegistryFunctionalMappingRecord functional_mapping, *functional_mapping_found;
		functional_mapping.from_namespace = from_ns_quark;
		functional_mapping.to_namespace = to_ns_quark;
		functional_mapping_found = g_hash_table_lookup(functional_mappings, &functional_mapping);

		if (functional_mapping_found) {
			return functional_mapping_found->translation_function;
		}
		return NULL;
}

static const char *lasso_registry_get_functional_mapping(GHashTable *functional_mappings,
		GQuark from_ns_namespace, const char *from_name, GQuark to_ns_namespace)
{
	LassoRegistryTranslationFunction translation_function;

	translation_function = lasso_registry_get_translation_function(functional_mappings, from_ns_namespace, to_ns_namespace);
	if (translation_function) {
		return translation_function(g_quark_to_string(from_ns_namespace), from_name, g_quark_to_string(to_ns_namespace));
	}
	return NULL;
}

static const char *lasso_registry_get_direct_mapping(GHashTable *direct_mappings,
		GQuark from_ns_quark, const char *from_name, GQuark to_ns_quark)
{
	GQuark from_name_quark = g_quark_try_string(from_name);
	LassoRegistryDirectMappingRecord record, *found;

	if (from_name_quark == 0)
		return NULL;

	record.from_namespace = from_ns_quark;
	record.from_name = from_name_quark;
	record.to_namespace = to_ns_quark;

	found = g_hash_table_lookup(direct_mappings, &record);

	if (found) {
		return g_quark_to_string(found->to_name);
	}
	return NULL;
}

/**
 * lasso_regsitry_get_mapping:
 *
 * Retrieve the mapping of a QName into another namespace, i.e. to another
 * QName. It first tries the functional mapping, then tries with the direct mapping.
 *
 * Return value: a constant string of NULL if no mapping exist.
 */
const char* lasso_registry_get_mapping(LassoRegistry *registry, const char *from_namespace,
		const char *from_name, const char *to_namespace)
{
	GQuark from_ns_quark, to_ns_quark;
	const char *ret = NULL;

	from_ns_quark = g_quark_try_string(from_namespace);
	to_ns_quark = g_quark_try_string(to_namespace);

	if (from_ns_quark == 0 || to_ns_quark == 0) {
		return NULL;
	}

	ret = lasso_registry_get_functional_mapping(registry->functional_mapping, from_ns_quark, from_name, to_ns_quark);
	if (ret == NULL) {
		ret = lasso_registry_get_direct_mapping(registry->direct_mapping, from_ns_quark, from_name, to_ns_quark);
	}

	return ret;
}

/**
 * lasso_registry_add_direct_mapping:
 *
 * Add a new mapping from a QName to a QName.
 *
 * Return value: 0 if successfull, LASSO_REGISTRY_ERROR_KEY_EXISTS if it already exists,
 * LASSO_PARAM_ERROR_INVALID_VALUE if arguments
 * are invalid.
 */
gint lasso_registry_add_direct_mapping(LassoRegistry *registry, const char *from_namespace,
		const char *from_name, const char *to_namespace, const char *to_name)
{
	LassoRegistryDirectMappingRecord *a_record;

	g_return_val_if_fail(registry && from_namespace && from_name && to_namespace && to_name, LASSO_PARAM_ERROR_INVALID_VALUE);

	if (lasso_registry_get_mapping(registry, from_namespace, from_name, to_namespace)) {
		return LASSO_REGISTRY_ERROR_KEY_EXISTS;
	}
	a_record = g_new0(LassoRegistryDirectMappingRecord, 1);
	a_record->from_namespace = g_quark_from_string(from_namespace);
	a_record->from_name = g_quark_from_string(from_name);
	a_record->to_namespace = g_quark_from_string(to_namespace);
	a_record->to_name = g_quark_from_string(to_name);
	g_hash_table_insert(registry->direct_mapping, a_record, a_record);
	return 0;
}

/**
 * lasso_registry_add_functional_mapping:
 * @registry: a #LassoRegistry
 * @from_namespace: URI of the source namespace
 * @to_namespace: URI of the destination namespace
 * @translation_function: a function mapping string to string from the first namespace to the second one
 *
 * Register a new mapping from from_namesapce to to_namespace using the
 * translation_function. This functions is not forced to return a value for
 * any string, it can return NULL.
 *
 * Return value: 0 if successfull, LASSO_REGISTRY_ERROR_KEY_EXISTS if this mapping is already registered,
 * LASSO_PARAM_ERROR_INVALID_VALUE if one the argument is invalid.
 */
gint lasso_registry_add_functional_mapping(LassoRegistry *registry, const char *from_namespace,
		const char *to_namespace, LassoRegistryTranslationFunction translation_function)
{
	LassoRegistryFunctionalMappingRecord *a_record;
	GQuark to_ns_quark, from_ns_quark;

	g_return_val_if_fail(registry != NULL && from_namespace != NULL && to_namespace != NULL, LASSO_PARAM_ERROR_INVALID_VALUE);
	from_ns_quark = g_quark_from_string(from_namespace);
	to_ns_quark = g_quark_from_string(to_namespace);
	if (lasso_registry_get_translation_function(registry->functional_mapping, from_ns_quark, to_ns_quark)) {
		return LASSO_REGISTRY_ERROR_KEY_EXISTS;
	}
	a_record = g_new0(LassoRegistryFunctionalMappingRecord, 1);
	a_record->from_namespace = from_ns_quark;
	a_record->to_namespace = to_ns_quark;
	a_record->translation_function = translation_function;

	g_hash_table_insert(registry->functional_mapping, a_record, a_record);

	return 0;
}

/**
 * lasso_registry_default_add_direct_mapping:
 * @from_namespace: the namespace of the mapped QName
 * @from_name: the name of the mapped QName
 * @to_namespace: the namepsace of the mapped to QName
 * @to_name: the name of the mapped to QName
 *
 * Add a new mapping from a QName to a QName.
 *
 * Return value: 0 if successfull, LASSO_REGISTRY_ERROR_KEY_EXISTS if this mapping is already registered,
 * LASSO_PARAM_ERROR_INVALID_VALUE if one the argument is invalid.
 */
gint lasso_registry_default_add_direct_mapping(const char *from_namespace,
		const char *from_name, const char *to_namespace, const char *to_name)
{
	LassoRegistry *default_registry = lasso_registry_get_default();

	return lasso_registry_add_direct_mapping(default_registry, from_namespace, from_name, to_namespace, to_name);
}

/**
 * lasso_registry_default_add_functional_mapping:
 *
 * @from_namespace: URI of the source namespace
 * @to_namespace: URI of the destination namespace
 * @translation_function: a function mapping string to string from the first namespace to the second one
 *
 * Register a new mapping from from_namesapce to to_namespace using the translation_function into
 * the default mapping. This functions is not forced to return a value for any string, it can return
 * NULL.
 *
 * Return value: 0 if successfull, LASSO_REGISTRY_ERROR_KEY_EXISTS if this mapping is already registered,
 * LASSO_PARAM_ERROR_INVALID_VALUE if one the argument is invalid.
 */
gint lasso_registry_default_add_functional_mapping(const char *from_namespace,
		const char *to_namespace, LassoRegistryTranslationFunction translation_function)
{
	LassoRegistry *default_registry = lasso_registry_get_default();

	return lasso_registry_add_functional_mapping(default_registry, from_namespace, to_namespace, translation_function);
}


/**
 * lasso_registry_default_get_mapping:
 * @from_namespace: the namespace of the mapped QName
 * @from_name: the name of the mapped QName
 * @to_namespace: the namepsace of the mapped to QName
 *
 * Retrieve the name of the QName in the namespace to_namespace that maps the
 * QName from_namespace:from_name.
 *
 * Return value: the name string of the QName or NULL if no mapping exists.
 */
const char* lasso_registry_default_get_mapping(const char *from_namespace,
		const char *from_name, const char *to_namespace)
{
	LassoRegistry *default_registry = lasso_registry_get_default();

	return lasso_registry_get_mapping(default_registry, from_namespace, from_name, to_namespace);
}