st-handler.c

来自「linux下网络收音机的源码」· C语言 代码 · 共 1,838 行 · 第 1/4 页

			 GParamSpec *pspec)
{
  STHandler *handler = ST_HANDLER(object);

  switch (prop_id)
    {
    case PROP_NAME:
      handler->priv->name = g_value_dup_string(value);
      break;

    case PROP_DUMMY:
      handler->priv->dummy = g_value_get_boolean(value);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
      break;
    }
}

STHandler *
st_handler_new_dummy (const char *name)
{
  g_return_val_if_fail(name != NULL, NULL);

  return g_object_new(ST_TYPE_HANDLER,
		      "name", name,
		      "dummy", TRUE,
		      NULL);
}

void
st_handler_complete (STHandler *handler)
{
  g_return_if_fail(ST_IS_HANDLER(handler));

  if (! handler->priv->stock_categories)
    {
      STCategoryBag *category_bag;

      handler->priv->stock_categories = g_node_new(NULL);

      category_bag = st_category_bag_new(handler);
      ST_CATEGORY(category_bag)->name = g_strdup(ST_CATEGORY_BAG_MAIN);

      g_node_append_data(handler->priv->stock_categories, category_bag);
    }

  handler->priv->categories = st_category_store_new(handler->priv->stock_categories);
}

gboolean
st_handler_validate (STHandler *handler, GError **err)
{
  if (! handler)
    {
      g_set_error(err, 0, 0, _("passed handler is NULL"));
      return FALSE;
    }
  if (! ST_IS_HANDLER(handler))
    {
      g_set_error(err, 0, 0, _("passed handler is not a STHandler object"));
      return FALSE;
    }
  if (! handler->priv->label)
    {
      g_set_error(err, 0, 0, _("handler label is not set"));
      return FALSE;
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_STREAM_NEW))
    {
      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_STREAM_NEW is not bound"));
      return FALSE;
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_STREAM_FIELD_GET))
    {
      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_STREAM_FIELD_GET is not bound"));
      return FALSE;
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_STREAM_FIELD_SET))
    {
      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_STREAM_FIELD_SET is not bound"));
      return FALSE;
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_STREAM_MODIFY))
    {
      GSList *l;

      SG_LIST_FOREACH(l, handler->priv->fields)
        {
	  STHandlerField *field = l->data;

	  if (ST_HANDLER_FIELD_IS_EDITABLE(field))
	    {
	      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_STREAM_MODIFY is not bound, but field \"%s\" is editable"), st_handler_field_get_label(field));
	      return FALSE;
	    }
	}
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_STREAM_FREE))
    {
      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_STREAM_FREE is not bound"));
      return FALSE;
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_CATEGORY_NEW))
    {
      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_CATEGORY_NEW is not bound"));
      return FALSE;
    }
  if (! st_handler_event_is_bound(handler, ST_HANDLER_EVENT_CATEGORY_FREE))
    {
      g_set_error(err, 0, 0, _("ST_HANDLER_EVENT_CATEGORY_FREE is not bound"));
      return FALSE;
    }
  /*
   * If handler->priv->stock_categories is NULL, we'll add the main
   * category in st_handler_complete().
   */
  if (handler->priv->stock_categories && ! st_handler_get_stock_category(handler, ST_CATEGORY_BAG_MAIN))
    {
      g_set_error(err, 0, 0, _("main category is missing"));
      return FALSE;
    }
  
  return TRUE;
}

gboolean
st_handler_reload (STHandler *handler,
		   STCategoryBag *category_bag,
		   GNode **categories,
		   STStreamStore **stream_store,
		   GError **err)
{
  gboolean status;

  g_return_val_if_fail(ST_IS_HANDLER(handler), FALSE);
  g_return_val_if_fail(ST_IS_CATEGORY_BAG(category_bag), FALSE);
  g_return_val_if_fail(categories != NULL, FALSE);
  g_return_val_if_fail(stream_store != NULL, FALSE);

  if (st_handler_event_is_bound(handler, ST_HANDLER_EVENT_RELOAD_MULTIPLE))
    {
      GHashTable *stream_lists;

      status = st_handler_reload_multiple(handler,
					  categories,
					  &stream_lists,
					  err);
      if (status)
	{
	  g_hash_table_foreach(stream_lists, st_handler_reload_multiple_cb, handler);
	  g_hash_table_destroy(stream_lists);

	  *stream_store = st_handler_get_streams(handler, ST_CATEGORY(category_bag)->name);
	}
    }
  else
    {
      GSList *streams;
      
      status = st_handler_reload_single(handler,
					category_bag,
					categories,
					&streams,
					err);
      if (status)
	{
	  *stream_store = st_stream_store_new(handler);
	  st_stream_store_append_list(*stream_store, streams);
	  sg_objects_free(streams);
	  
	  st_stream_store_touch(*stream_store);
	  st_handler_set_streams(handler, ST_CATEGORY(category_bag)->name, *stream_store);
	}
    }

  return status;
}

static void
st_handler_reload_multiple_cb (gpointer key,
			       gpointer value,
			       gpointer user_data)
{
  const char *category_name = key;
  GSList *streams = value;
  STHandler *handler = user_data;
  STStreamStore *stream_store;

  stream_store = st_stream_store_new(handler);
  st_stream_store_append_list(stream_store, streams);
  st_stream_store_touch(stream_store);

  st_handler_set_streams(handler, category_name, stream_store);
  g_object_unref(stream_store);
}

static gboolean
st_handler_reload_single (STHandler *handler,
			  STCategoryBag *category_bag,
			  GNode **category_bags,
			  GSList **stream_bags,
			  GError **err)
{
  gboolean status;
  GNode *categories = NULL;
  GList *streams = NULL;

  g_return_val_if_fail(ST_IS_HANDLER(handler), FALSE);
  g_return_val_if_fail(ST_IS_CATEGORY_BAG(category_bag), FALSE);
  g_return_val_if_fail(category_bags != NULL, FALSE);
  g_return_val_if_fail(stream_bags != NULL, FALSE);

  status = st_handler_event_reload(handler,
				   ST_CATEGORY(category_bag),
				   &categories,
				   &streams,
				   err);
  
  if (status)
    {
      *category_bags = st_handler_categories_to_bags(handler, categories);
      *stream_bags = st_handler_streams_to_bags(handler, streams);

      if (categories) g_node_destroy(categories);
      g_list_free(streams);
    }
  else
    {
      st_handler_categories_free(handler, categories);
      st_handler_streams_free(handler, streams);
    }
  
  return status;
}

static gboolean
st_handler_reload_multiple (STHandler *handler,
			    GNode **category_bags,
			    GHashTable **stream_bag_lists,
			    GError **err)
{
  gboolean status;
  GNode *categories = NULL;
  GHashTable *stream_lists = NULL;

  g_return_val_if_fail(ST_IS_HANDLER(handler), FALSE);
  g_return_val_if_fail(category_bags != NULL, FALSE);
  g_return_val_if_fail(stream_bag_lists != NULL, FALSE);

  status = st_handler_event_reload_multiple(handler,
					    &categories,
					    &stream_lists,
					    err);

  if (status)
    {
      *category_bags = st_handler_categories_to_bags(handler, categories);
      *stream_bag_lists = st_handler_stream_lists_to_bags(handler, stream_lists);

      if (categories) g_node_destroy(categories);
      g_hash_table_destroy(stream_lists);
    }
  else
    {
      st_handler_categories_free(handler, categories);
      st_handler_stream_lists_free(handler, stream_lists);
    }

  return status;
}

static GNode *
st_handler_categories_to_bags (STHandler *handler, GNode *categories)
{
  GNode *copy;

  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  if (categories)
    {
      copy = g_node_copy(categories);
      g_node_traverse(copy,
		      G_PRE_ORDER,
		      G_TRAVERSE_ALL,
		      -1,
		      st_handler_categories_to_bags_cb,
		      handler);
    }
  else
    copy = g_node_new(NULL);

  return copy;
}

static gboolean
st_handler_categories_to_bags_cb (GNode *node, gpointer data)
{
  if (node->data)
    node->data = st_category_bag_new_from_category(data, node->data);

  return FALSE;			/* continue */
}

static void
st_handler_categories_free (STHandler *handler, GNode *categories)
{
  g_return_if_fail(ST_IS_HANDLER(handler));

  if (categories)
    {
      g_node_traverse(categories,
		      G_PRE_ORDER,
		      G_TRAVERSE_ALL,
		      -1,
		      st_handler_categories_free_cb,
		      handler);
      g_node_destroy(categories);
    }
}

static gboolean
st_handler_categories_free_cb (GNode *node, gpointer data)
{
  if (node->data)
    {
      STHandler *handler = data;
      st_handler_event_category_free(handler, node->data);
    }

  return FALSE;			/* continue */
}

static GSList *
st_handler_streams_to_bags (STHandler *handler, GList *streams)
{
  GSList *bags = NULL;
  GList *l;

  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  SG_LIST_FOREACH(l, streams)
    {
      STStreamBag *bag;

      bag = st_stream_bag_new_from_stream(handler, l->data);
      bags = g_slist_append(bags, bag);
    }

  return bags;
}

static void
st_handler_streams_free (STHandler *handler, GList *streams)
{
  GList *l;

  g_return_if_fail(ST_IS_HANDLER(handler));

  SG_LIST_FOREACH(l, streams)
    st_handler_event_stream_free(handler, l->data);
  g_list_free(streams);
}

static GHashTable *
st_handler_stream_lists_to_bags (STHandler *handler, GHashTable *stream_lists)
{
  StreamListsToBagsInfo info;

  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  info.handler = handler;
  info.stream_bag_lists = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify) sg_objects_free);

  if (stream_lists)
    g_hash_table_foreach(stream_lists, st_handler_stream_lists_to_bags_cb, &info);
  
  return info.stream_bag_lists;
}

static void
st_handler_stream_lists_to_bags_cb (gpointer key,
				    gpointer value,
				    gpointer user_data)
{
  const char *category_name = key;
  GList *streams = value;
  GSList *stream_bags;
  StreamListsToBagsInfo *info = user_data;

  stream_bags = st_handler_streams_to_bags(info->handler, streams);
  g_list_free(streams);

  g_hash_table_insert(info->stream_bag_lists, g_strdup(category_name), stream_bags);
}

static void
st_handler_stream_lists_free (STHandler *handler, GHashTable *stream_lists)
{
  g_return_if_fail(ST_IS_HANDLER(handler));
  
  if (stream_lists)
    {
      g_hash_table_foreach(stream_lists, st_handler_stream_lists_free_cb, handler);
      g_hash_table_destroy(stream_lists);
    }
}

static void
st_handler_stream_lists_free_cb (gpointer key,
				 gpointer value,
				 gpointer user_data)
{
  GList *streams = value;
  STHandler *handler = user_data;

  st_handler_streams_free(handler, streams);
}

STCategoryStore *
st_handler_get_categories (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);
  g_return_val_if_fail(handler->priv->categories != NULL, NULL);

  return g_object_ref(handler->priv->categories);
}

void
st_handler_set_streams (STHandler *handler,
			const char *category_name,
			STStreamStore *streams)
{
  g_return_if_fail(ST_IS_HANDLER(handler));
  g_return_if_fail(category_name != NULL);
  g_return_if_fail(ST_IS_STREAM_STORE(streams));

  g_mutex_lock(handler->priv->streams_mutex);
  g_hash_table_insert(handler->priv->streams,
		      g_strdup(category_name),
		      g_object_ref(streams));
  g_mutex_unlock(handler->priv->streams_mutex);
}

STStreamStore *
st_handler_get_streams (STHandler *handler, const char *category_name)
{
  STStreamStore *store;

  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);
  g_return_val_if_fail(category_name != NULL, NULL);

  g_mutex_lock(handler->priv->streams_mutex);
  store = g_hash_table_lookup(handler->priv->streams, category_name);
  if (store)
    g_object_ref(store);
  g_mutex_unlock(handler->priv->streams_mutex);

  return store;