/* Pango
 * pango-threadsafe.h: Thread-safe alternatives of glib datastructures
 *
 * Copyright (C) 2012 Google, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Google author(s): Behdad Esfahbod
 */

#ifndef __PANGO_THREADSAFE_H__
#define __PANGO_THREADSAFE_H__

#include <glib.h>
#include <pango/pango.h>

G_BEGIN_DECLS

typedef struct _PHashTable {
  GHashTable *ht;
  GMutex mx;
} PHashTable;


static inline
PHashTable* p_hash_table_new               (GHashFunc       hash_func,
                                            GEqualFunc      key_equal_func)
{
  PHashTable *p = g_slice_new0 (PHashTable);

  p->ht = g_hash_table_new (hash_func, key_equal_func);

  return p;
}

static inline
PHashTable* p_hash_table_new_full          (GHashFunc       hash_func,
                                            GEqualFunc      key_equal_func,
                                            GDestroyNotify  key_destroy_func,
                                            GDestroyNotify  value_destroy_func)
{
  PHashTable *p = g_slice_new0 (PHashTable);

  p->ht = g_hash_table_new_full (hash_func,
				 key_equal_func,
				 key_destroy_func,
				 value_destroy_func);

  return p;
}

static inline
void        p_hash_table_destroy           (PHashTable     *hash_table)
{
  g_hash_table_destroy (hash_table->ht);
  g_mutex_clear (&hash_table->mx);
  g_slice_free (PHashTable, hash_table);
}

static inline
void        p_hash_table_insert            (PHashTable     *hash_table,
                                            gpointer        key,
                                            gpointer        value)
{
  g_mutex_lock (&hash_table->mx);
  g_hash_table_insert (hash_table->ht, key, value);
  g_mutex_unlock (&hash_table->mx);
}

static inline
void        p_hash_table_replace           (PHashTable     *hash_table,
                                            gpointer        key,
                                            gpointer        value)
{
  g_mutex_lock (&hash_table->mx);
  g_hash_table_replace (hash_table->ht, key, value);
  g_mutex_unlock (&hash_table->mx);
}

static inline
gboolean    p_hash_table_remove            (PHashTable     *hash_table,
                                            gconstpointer   key)
{
  gboolean ret;
  g_mutex_lock (&hash_table->mx);
  ret = g_hash_table_remove (hash_table->ht, key);
  g_mutex_unlock (&hash_table->mx);
  return ret;
}

static inline
gpointer    p_hash_table_lookup            (PHashTable     *hash_table,
                                            gconstpointer   key)
{
  gpointer ret;
  g_mutex_lock (&hash_table->mx);
  ret = g_hash_table_lookup (hash_table->ht, key);
  g_mutex_unlock (&hash_table->mx);
  return ret;
}

static inline
void        p_hash_table_foreach           (PHashTable     *hash_table,
                                            GHFunc          func,
                                            gpointer        user_data)
{
  g_mutex_lock (&hash_table->mx);
  g_hash_table_foreach (hash_table->ht, func, user_data);
  g_mutex_unlock (&hash_table->mx);
}


G_END_DECLS

#endif /* __PANGO_THREADSAFE_H__ */