+++ /dev/null
-/* mongo-bson.c
- *
- * Copyright (C) 2011 Christian Hergert <christian@catch.com>
- *
- * This file 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 file 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 General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <string.h>
-
-#include "mongo-bson.h"
-#include "mongo-debug.h"
-
-/**
- * SECTION:mongo-bson
- * @title: MongoBson
- * @short_description: BSON document structure.
- *
- * #MongoBson reprsents a BSON document that can be created, traversed,
- * and used throughout the Mongo-GLib library. They are referenced counted
- * structures that are referenced with mongo_bson_ref() and unreferenced
- * with mongo_bson_unref(). Memory allocated by the #MongoBson structure
- * is automatically released when the reference count reaches zero.
- *
- * You can iterate through the fields in a #MongoBson using the
- * mongo_bson_iter_* functions. #MongoBsonIter contains the state of
- * the iterator and is used to access the current value. You may jump
- * to the next field matching a given name using mongo_bson_iter_find().
- *
- * Keep in mind that BSON documents do not use modified UTF-8 like most
- * of GLib. Therefore, they may have %NULL characters within the target
- * string instead of the two-byte sequenced used in modified UTF-8. This
- * may change at some point to incur an extra cost for conversion to
- * modified UTF-8.
- */
-
-struct _MongoBson
-{
- volatile gint ref_count;
- GByteArray *buf;
- const guint8 *static_data;
- gsize static_len;
- GDestroyNotify static_notify;
-};
-
-typedef enum
-{
- ITER_TRUST_UTF8 = 1 << 0,
- ITER_INVALID_UTF8 = 1 << 1,
-} IterFlags;
-
-#define ITER_IS_TYPE(iter, type) \
- (GPOINTER_TO_INT(iter->user_data5) == type)
-
-/**
- * mongo_bson_dispose:
- * @bson: A #MongoBson.
- *
- * Cleans up @bson and free allocated resources.
- */
-static void
-mongo_bson_dispose (MongoBson *bson)
-{
- if (bson->buf) {
- g_byte_array_free(bson->buf, TRUE);
- } else if (bson->static_notify) {
- bson->static_notify((guint *)bson->static_data);
- }
-}
-
-/**
- * mongo_bson_new_from_data:
- * @buffer: (in): The buffer to create a #MongoBson.
- * @length: (in): The length of @buffer.
- *
- * Creates a new #MongoBson instance using the buffer and the length.
- *
- * Returns: A new #MongoBson that should be freed with mongo_bson_unref().
- */
-MongoBson *
-mongo_bson_new_from_data (const guint8 *buffer,
- gsize length)
-{
- MongoBson *bson;
- guint32 bson_len;
-
- g_return_val_if_fail(buffer != NULL, NULL);
-
- /*
- * The first 4 bytes of a BSON are the length, including the 4 bytes
- * containing said length.
- */
- memcpy(&bson_len, buffer, sizeof bson_len);
- bson_len = GUINT32_FROM_LE(bson_len);
- if (bson_len != length) {
- return NULL;
- }
-
- bson = g_slice_new0(MongoBson);
- bson->ref_count = 1;
- bson->buf = g_byte_array_sized_new(length);
- g_byte_array_append(bson->buf, buffer, length);
-
- return bson;
-}
-
-/**
- * mongo_bson_new_take_data:
- * @buffer: (in): The buffer to use when creating the #MongoBson.
- * @length: (in): The length of @buffer.
- *
- * Creates a new instance of #MongoBson using the buffers provided.
- * @buffer should be a buffer that can work with g_realloc() and
- * g_free().
- *
- * Returns: (transfer full): A newly allocated #MongoBson.
- */
-MongoBson *
-mongo_bson_new_take_data (guint8 *buffer,
- gsize length)
-{
- MongoBson *bson;
- guint32 bson_len;
-
- g_return_val_if_fail(buffer, NULL);
- g_return_val_if_fail(length >= 5, NULL);
-
- /*
- * The first 4 bytes of a BSON are the length, including the 4 bytes
- * containing said length.
- */
- memcpy(&bson_len, buffer, sizeof bson_len);
- bson_len = GUINT32_FROM_LE(bson_len);
- if (bson_len != length) {
- return NULL;
- }
-
- bson = g_slice_new0(MongoBson);
- bson->ref_count = 1;
-#if GLIB_CHECK_VERSION(2, 32, 0)
- bson->buf = g_byte_array_new_take(buffer, length);
-#else
- bson->buf = g_byte_array_new();
- bson->buf->data = buffer;
- bson->buf->len = length;
-#endif
-
- return bson;
-}
-
-/**
- * mongo_bson_new_from_static_data:
- * @buffer: (in) (transfer full): The static buffer to use.
- * @length: (in): The number of bytes in @buffer.
- * @notify: (in): A #GDestroyNotify to free @buffer.
- *
- * Creates a new #MongoBson structure using @buffer. This does not copy
- * the content of the buffer and uses it directly. Therefore, you MUST make
- * sure that the structure outlives the buffer beneath it.
- *
- * If the structure is referenced with mongo_bson_ref(), the contents of
- * the buffer will be copied.
- *
- * When the structure is released, @notify will be called to release
- * @buffer.
- *
- * You MAY NOT modify the contents of @buffer using any of the
- * mongo_bson_append methods.
- *
- * Returns: A newly created #MongoBson structure.
- */
-MongoBson *
-mongo_bson_new_from_static_data (guint8 *buffer,
- gsize length,
- GDestroyNotify notify)
-{
- MongoBson *bson;
- guint32 bson_len;
-
- g_return_val_if_fail(buffer, NULL);
- g_return_val_if_fail(length >= 5, NULL);
-
- /*
- * The first 4 bytes of a BSON are the length, including the 4 bytes
- * containing said length.
- */
- memcpy(&bson_len, buffer, sizeof bson_len);
- bson_len = GUINT32_FROM_LE(bson_len);
- if (bson_len != length) {
- return NULL;
- }
-
- bson = g_slice_new0(MongoBson);
- bson->ref_count = 1;
- bson->static_data = buffer;
- bson->static_len = length;
- bson->static_notify = notify;
-
- return bson;
-}
-
-/**
- * mongo_bson_new_empty:
- *
- * Creates a new instance of #MongoBson. This function is similar to
- * mongo_bson_new() except that it does not pre-populate the newly created
- * #MongoBson instance with an _id field.
- *
- * Returns: An empty #MongoBson that should be freed with mongo_bson_unref().
- */
-MongoBson *
-mongo_bson_new_empty (void)
-{
- MongoBson *bson;
- gint32 len = GINT_TO_LE(5);
- guint8 trailing = 0;
-
- bson = g_slice_new0(MongoBson);
- bson->ref_count = 1;
- bson->buf = g_byte_array_sized_new(16);
-
- g_byte_array_append(bson->buf, (guint8 *)&len, sizeof len);
- g_byte_array_append(bson->buf, (guint8 *)&trailing, sizeof trailing);
-
- g_assert(bson);
- g_assert(bson->buf);
- g_assert_cmpint(bson->buf->len, ==, 5);
-
- return bson;
-}
-
-/**
- * mongo_bson_new:
- *
- * Creates a new instance of #MongoBson. The #MongoBson instance is
- * pre-populated with an _id field and #MongoObjectId value. This value
- * is generated on the local machine and follows the guidelines suggested
- * by the BSON ObjectID specificiation.
- *
- * Returns: A #MongoBson that should be freed with mongo_bson_unref().
- */
-MongoBson *
-mongo_bson_new (void)
-{
- MongoObjectId *oid;
- MongoBson *bson;
-
- bson = mongo_bson_new_empty();
- oid = mongo_object_id_new();
- mongo_bson_append_object_id(bson, "_id", oid);
- mongo_object_id_free(oid);
-
- return bson;
-}
-
-/**
- * mongo_bson_dup:
- * @bson: (in): A #MongoBson.
- *
- * Creates a new #MongoBson by copying @bson.
- *
- * Returns: (transfer full): A newly allocated #MongoBson.
- */
-MongoBson *
-mongo_bson_dup (const MongoBson *bson)
-{
- const guint8 *data;
- MongoBson *ret = NULL;
- gsize data_len = 0;
-
- if (bson && (data = mongo_bson_get_data(bson, &data_len))) {
- ret = mongo_bson_new_from_data(data, data_len);
- }
-
- return ret;
-}
-
-/**
- * mongo_bson_ref:
- * @bson: (in): A #MongoBson.
- *
- * Atomically increments the reference count of @bson by one. If @bson
- * contains a static buffer, then a new structure will be returned.
- *
- * Returns: (transfer full): @bson.
- */
-MongoBson *
-mongo_bson_ref (MongoBson *bson)
-{
- g_return_val_if_fail(bson != NULL, NULL);
- g_return_val_if_fail(bson->ref_count > 0, NULL);
-
- if (G_UNLIKELY(bson->static_data)) {
- return mongo_bson_new_from_data(bson->static_data, bson->static_len);
- }
- g_atomic_int_inc(&bson->ref_count);
- return bson;
-}
-
-/**
- * mongo_bson_unref:
- * @bson: A MongoBson.
- *
- * Atomically decrements the reference count of @bson by one. When the
- * reference count reaches zero, the structure will be destroyed and
- * freed.
- */
-void
-mongo_bson_unref (MongoBson *bson)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(bson->ref_count > 0);
-
- if (g_atomic_int_dec_and_test(&bson->ref_count)) {
- mongo_bson_dispose(bson);
- g_slice_free(MongoBson, bson);
- }
-}
-
-/**
- * mongo_bson_get_empty:
- * @bson: (in): A #MongoBson.
- *
- * Checks to see if the contents of MongoBson are empty.
- *
- * Returns: None.
- * Side effects: None.
- */
-gboolean
-mongo_bson_get_empty (MongoBson *bson)
-{
- guint32 len;
- g_return_val_if_fail(bson != NULL, FALSE);
- len = bson->buf ? bson->buf->len : bson->static_len;
- return (len <= 5);
-}
-
-/**
- * mongo_bson_get_data:
- * @bson: (in): A #MongoBson.
- * @length: (out): A location for the buffer length.
- *
- * Fetches the BSON buffer.
- *
- * Returns: (transfer none): The #MongoBson buffer.
- */
-const guint8 *
-mongo_bson_get_data (const MongoBson *bson,
- gsize *length)
-{
- g_return_val_if_fail(bson != NULL, NULL);
- g_return_val_if_fail(length != NULL, NULL);
-
- if (bson->buf) {
- *length = bson->buf->len;
- return bson->buf->data;
- }
-
- *length = bson->static_len;
- return bson->static_data;
-}
-
-/**
- * mongo_bson_get_size:
- * @bson: (in): A #MongoBson.
- *
- * Retrieves the size of the #MongoBson buffer.
- *
- * Returns: A gsize.
- */
-gsize
-mongo_bson_get_size (const MongoBson *bson)
-{
- g_return_val_if_fail(bson, 0);
- return bson->buf->len;
-}
-
-/**
- * mongo_bson_get_type:
- *
- * Retrieve the #GType for the #MongoBson boxed type.
- *
- * Returns: A #GType.
- */
-GType
-mongo_bson_get_type (void)
-{
- static GType type_id = 0;
- static gsize initialized = FALSE;
-
- if (g_once_init_enter(&initialized)) {
- type_id = g_boxed_type_register_static("MongoBson",
- (GBoxedCopyFunc)mongo_bson_ref,
- (GBoxedFreeFunc)mongo_bson_unref);
- g_once_init_leave(&initialized, TRUE);
- }
-
- return type_id;
-}
-
-/**
- * mongo_bson_type_get_type:
- *
- * Fetches the #GType for a #MongoBsonType.
- *
- * Returns: A #GType.
- */
-GType
-mongo_bson_type_get_type (void)
-{
- static GType type_id = 0;
- static gsize initialized = FALSE;
- static GEnumValue values[] = {
- { MONGO_BSON_DOUBLE, "MONGO_BSON_DOUBLE", "DOUBLE" },
- { MONGO_BSON_UTF8, "MONGO_BSON_UTF8", "UTF8" },
- { MONGO_BSON_DOCUMENT, "MONGO_BSON_DOCUMENT", "DOCUMENT" },
- { MONGO_BSON_ARRAY, "MONGO_BSON_ARRAY", "ARRAY" },
- { MONGO_BSON_UNDEFINED, "MONGO_BSON_UNDEFINED", "UNDEFINED" },
- { MONGO_BSON_OBJECT_ID, "MONGO_BSON_OBJECT_ID", "OBJECT_ID" },
- { MONGO_BSON_BOOLEAN, "MONGO_BSON_BOOLEAN", "BOOLEAN" },
- { MONGO_BSON_DATE_TIME, "MONGO_BSON_DATE_TIME", "DATE_TIME" },
- { MONGO_BSON_NULL, "MONGO_BSON_NULL", "NULL" },
- { MONGO_BSON_REGEX, "MONGO_BSON_REGEX", "REGEX" },
- { MONGO_BSON_INT32, "MONGO_BSON_INT32", "INT32" },
- { MONGO_BSON_INT64, "MONGO_BSON_INT64", "INT64" },
- { 0 }
- };
-
- if (g_once_init_enter(&initialized)) {
- type_id = g_enum_register_static("MongoBsonType", values);
- g_once_init_leave(&initialized, TRUE);
- }
-
- return type_id;
-}
-
-/**
- * mongo_bson_append:
- * @bson: (in): A #MongoBson.
- * @type: (in) (type MongoBsonType): A #MongoBsonType.
- * @key: (in): The key for the field to append.
- * @data1: (in): The data for the first chunk of the data.
- * @len1: (in): The length of @data1.
- * @data2: (in): The data for the second chunk of the data.
- * @len2: (in): The length of @data2.
- *
- * This utility function helps us build a buffer for a #MongoBson given
- * the various #MongoBsonType<!-- -->'s and two-part data sections of
- * some fields.
- *
- * If @data2 is set, @data1 must also be set.
- */
-static void
-mongo_bson_append (MongoBson *bson,
- guint8 type,
- const gchar *key,
- const guint8 *data1,
- gsize len1,
- const guint8 *data2,
- gsize len2)
-{
- const guint8 trailing = 0;
- gint32 doc_len;
-
- g_return_if_fail(bson != NULL);
- g_return_if_fail(bson->buf != NULL);
- g_return_if_fail(type != 0);
- g_return_if_fail(key != NULL);
- g_return_if_fail(g_utf8_validate(key, -1, NULL));
- g_return_if_fail(data1 != NULL || len1 == 0);
- g_return_if_fail(data2 != NULL || len2 == 0);
- g_return_if_fail(!data2 || data1);
-
- /*
- * Overwrite our trailing byte with the type for this key.
- */
- bson->buf->data[bson->buf->len - 1] = type;
-
- /*
- * Append the field name as a BSON cstring.
- */
- g_byte_array_append(bson->buf, (guint8 *)key, strlen(key) + 1);
-
- /*
- * Append the data sections if needed.
- */
- if (data1) {
- g_byte_array_append(bson->buf, data1, len1);
- if (data2) {
- g_byte_array_append(bson->buf, data2, len2);
- }
- }
-
- /*
- * Append our trailing byte.
- */
- g_byte_array_append(bson->buf, &trailing, 1);
-
- /*
- * Update the document length of the buffer.
- */
- doc_len = GINT_TO_LE(bson->buf->len);
- memcpy(bson->buf->data, &doc_len, sizeof doc_len);
-}
-
-/**
- * mongo_bson_append_array:
- * @bson: (in): A #MongoBson.
- * @key: (in): The field name.
- * @value: (in): The #MongoBson array to append.
- *
- * Appends a #MongoBson containing an array. A #MongoBson array is a document
- * that contains fields with string keys containing integers incrementally.
- *
- * [[[
- * {"0": "First Value", "1": "Second Value"}
- * ]]]
- */
-void
-mongo_bson_append_array (MongoBson *bson,
- const gchar *key,
- MongoBson *value)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
- g_return_if_fail(value != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_ARRAY, key,
- value->buf->data, value->buf->len,
- NULL, 0);
-}
-
-/**
- * mongo_bson_append_boolean:
- * @bson: (in): A #MongoBson.
- * @key: (in): The string containing key.
- * @value: (in): A value to store in the document.
- *
- * Stores the value specified by @value as a boolean in the document
- * under @key.
- */
-void
-mongo_bson_append_boolean (MongoBson *bson,
- const gchar *key,
- gboolean value)
-{
- guint8 b = !!value;
-
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_BOOLEAN, key, &b, 1, NULL, 0);
-}
-
-/**
- * mongo_bson_append_bson:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A #MongoBson to store.
- *
- * Stores the #MongoBson in the document under @key.
- */
-void
-mongo_bson_append_bson (MongoBson *bson,
- const gchar *key,
- const MongoBson *value)
-{
- const guint8 *data;
- gsize data_len;
-
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
- g_return_if_fail(value != NULL);
-
- data = mongo_bson_get_data(value, &data_len);
- mongo_bson_append(bson, MONGO_BSON_DOCUMENT, key,
- data, data_len, NULL, 0);
-}
-
-#if GLIB_CHECK_VERSION(2, 26, 0)
-/**
- * mongo_bson_append_date_time:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A #GDateTime to store.
- *
- * Appends the #GDateTime to the #MongoBson under @key.
- */
-void
-mongo_bson_append_date_time (MongoBson *bson,
- const gchar *key,
- GDateTime *value)
-{
- GTimeVal tv;
-
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
- g_return_if_fail(value != NULL);
-
- if (!g_date_time_to_timeval(value, &tv)) {
- g_warning("GDateTime is outside of storable range, ignoring!");
- return;
- }
-
- mongo_bson_append_timeval(bson, key, &tv);
-}
-#endif
-
-/**
- * mongo_bson_append_double:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A #gdouble.
- *
- * Appends the #gdouble @value to the document under @key.
- */
-void
-mongo_bson_append_double (MongoBson *bson,
- const gchar *key,
- gdouble value)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_DOUBLE, key,
- (const guint8 *)&value, sizeof value,
- NULL, 0);
-}
-
-/**
- * mongo_bson_append_int:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A #gint32 containing the value.
- *
- * Appends @value to the document under @key.
- */
-void
-mongo_bson_append_int (MongoBson *bson,
- const gchar *key,
- gint32 value)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_INT32, key,
- (const guint8 *)&value, sizeof value,
- NULL, 0);
-}
-
-/**
- * mongo_bson_append_int64:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A #gint64 containing the value.
- *
- * Appends @value to the document under @key.
- */
-void
-mongo_bson_append_int64 (MongoBson *bson,
- const gchar *key,
- gint64 value)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_INT64, key,
- (const guint8 *)&value, sizeof value,
- NULL, 0);
-}
-
-/**
- * mongo_bson_append_null:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- *
- * Appends a %NULL value to the document under @key.
- */
-void
-mongo_bson_append_null (MongoBson *bson,
- const gchar *key)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_NULL, key, NULL, 0, NULL, 0);
-}
-
-/**
- * mongo_bson_append_object_id:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @object_id: (in): A #MongoObjectId.
- *
- * Appends @object_id to the document under @key.
- */
-void
-mongo_bson_append_object_id (MongoBson *bson,
- const gchar *key,
- const MongoObjectId *object_id)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
- g_return_if_fail(object_id != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_OBJECT_ID, key,
- (const guint8 *)object_id, 12,
- NULL, 0);
-}
-
-/**
- * mongo_bson_append_regex:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @regex: (in): A string containing a regex.
- * @options: (in): Options for the regex.
- *
- * Appends a regex to the document under @key.
- */
-void
-mongo_bson_append_regex (MongoBson *bson,
- const gchar *key,
- const gchar *regex,
- const gchar *options)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
- g_return_if_fail(regex != NULL);
-
- if (!options) {
- options = "";
- }
-
- mongo_bson_append(bson, MONGO_BSON_REGEX, key,
- (const guint8 *)regex, strlen(regex) + 1,
- (const guint8 *)options, strlen(options) + 1);
-}
-
-/**
- * mongo_bson_append_string:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A string containing the value.
- *
- * Stores the string @value in the document under @key.
- */
-void
-mongo_bson_append_string (MongoBson *bson,
- const gchar *key,
- const gchar *value)
-{
- guint32 value_len;
- guint32 value_len_swab;
-
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
- g_return_if_fail(g_utf8_validate(value, -1, NULL));
-
- value = value ? value : "";
- value_len = strlen(value) + 1;
- value_len_swab = GUINT32_TO_LE(value_len);
-
- mongo_bson_append(bson, MONGO_BSON_UTF8, key,
- (const guint8 *)&value_len_swab, sizeof value_len_swab,
- (const guint8 *)value, value_len);
-}
-
-/**
- * mongo_bson_append_timeval:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- * @value: (in): A #GTimeVal containing the date and time.
- *
- * Appends the date and time represented by @value up to milliseconds.
- * The value is stored in the document under @key.
- *
- * See also: mongo_bson_append_date_time().
- */
-void
-mongo_bson_append_timeval (MongoBson *bson,
- const gchar *key,
- GTimeVal *value)
-{
- guint64 msec;
-
- g_return_if_fail(bson);
- g_return_if_fail(key);
- g_return_if_fail(value);
-
- msec = (value->tv_sec * 1000) + (value->tv_usec / 1000);
- mongo_bson_append(bson, MONGO_BSON_DATE_TIME, key,
- (const guint8 *)&msec, sizeof msec,
- NULL, 0);
-}
-
-/**
- * mongo_bson_append_undefined:
- * @bson: (in): A #MongoBson.
- * @key: (in): A string containing the key.
- *
- * Appends a javascript "undefined" value in the document under @key.
- */
-void
-mongo_bson_append_undefined (MongoBson *bson,
- const gchar *key)
-{
- g_return_if_fail(bson != NULL);
- g_return_if_fail(key != NULL);
-
- mongo_bson_append(bson, MONGO_BSON_UNDEFINED, key,
- NULL, 0, NULL, 0);
-}
-
-/**
- * mongo_bson_iter_init:
- * @iter: an uninitialized #MongoBsonIter.
- * @bson: a #MongoBson.
- *
- * Initializes a #MongoBsonIter for iterating through a #MongoBson document.
- */
-void
-mongo_bson_iter_init (MongoBsonIter *iter,
- const MongoBson *bson)
-{
- g_return_if_fail(iter != NULL);
- g_return_if_fail(bson != NULL);
-
- memset(iter, 0, sizeof *iter);
- if (bson->static_data) {
- iter->user_data1 = (guint8 *)bson->static_data;
- iter->user_data2 = GINT_TO_POINTER(bson->static_len);
- } else {
- iter->user_data1 = bson->buf->data;
- iter->user_data2 = GINT_TO_POINTER(bson->buf->len);
- }
- iter->user_data3 = GINT_TO_POINTER(3); /* End of size buffer */
-}
-
-/**
- * mongo_bson_iter_set_trust_utf8:
- * @iter: (in): A #MongoBsonIter.
- * @trust_utf8: (in): If we should trust UTF-8.
- *
- * If the BSON document is known to have valid UTF-8 because it came
- * from a trusted source, then this may be used to disable UTF-8
- * validation. This can improve performance dramatically.
- */
-void
-mongo_bson_iter_set_trust_utf8 (MongoBsonIter *iter,
- gboolean trust_utf8)
-{
- g_return_if_fail(iter != NULL);
-
- if (trust_utf8) {
- iter->flags |= ITER_TRUST_UTF8;
- } else {
- iter->flags &= ~ITER_TRUST_UTF8;
- }
-}
-
-/**
- * mongo_bson_iter_find:
- * @iter: (in): A #MongoBsonIter.
- * @key: (in): A key to find in the BSON document.
- *
- * Iterates through all upcoming keys in a #MongoBsonIter until @key is
- * found or the end of the document has been reached.
- *
- * Returns: %TRUE if @key was found, otherwise %FALSE.
- */
-gboolean
-mongo_bson_iter_find (MongoBsonIter *iter,
- const gchar *key)
-{
- g_return_val_if_fail(iter != NULL, FALSE);
- g_return_val_if_fail(key != NULL, FALSE);
-
- while (mongo_bson_iter_next(iter)){
- if (!g_strcmp0(key, mongo_bson_iter_get_key(iter))) {
- return TRUE;
- }
- }
-
- return FALSE;
-}
-
-/**
- * mongo_bson_iter_get_key:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the key currently pointed to by @iter.
- *
- * Returns: A string containing the key.
- */
-const gchar *
-mongo_bson_iter_get_key (MongoBsonIter *iter)
-{
- g_return_val_if_fail(iter != NULL, NULL);
- return (const gchar *)iter->user_data4;
-}
-
-static MongoBson *
-mongo_bson_iter_get_value_document (MongoBsonIter *iter,
- MongoBsonType type)
-{
- const guint8 *buffer;
- gpointer endbuf;
- guint32 array_len;
-
- ENTRY;
-
- g_return_val_if_fail(iter != NULL, NULL);
- g_return_val_if_fail(iter->user_data1 != NULL, NULL);
- g_return_val_if_fail(iter->user_data2 != NULL, NULL);
- g_return_val_if_fail(iter->user_data6 != NULL, NULL);
- g_return_val_if_fail((type == MONGO_BSON_ARRAY) ||
- (type == MONGO_BSON_DOCUMENT), NULL);
-
- if (G_LIKELY(ITER_IS_TYPE(iter, type))) {
- endbuf = GSIZE_TO_POINTER(GPOINTER_TO_SIZE(iter->user_data1) +
- GPOINTER_TO_SIZE(iter->user_data2));
- if ((iter->user_data6 + 5) > endbuf) {
- return NULL;
- }
- memcpy(&array_len, iter->user_data6, sizeof array_len);
- array_len = GINT_FROM_LE(array_len);
- if ((iter->user_data6 + array_len) > endbuf) {
- return NULL;
- }
- buffer = iter->user_data6;
- return mongo_bson_new_from_data(buffer, array_len);
- }
-
- if (type == MONGO_BSON_ARRAY) {
- g_warning("Current key is not an array.");
- } else if (type == MONGO_BSON_DOCUMENT) {
- g_warning("Current key is not a document.");
- } else {
- g_assert_not_reached();
- }
-
- RETURN(NULL);
-}
-
-/**
- * mongo_bson_iter_get_value_array:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the array document current pointed to by @iter. This makes a
- * copy of the document and returns a new #MongoBson instance. For more
- * optimized cases, you may want to use mongo_bson_iter_recurse() to avoid
- * copying the memory if only iteration is needed.
- *
- * Returns: (transfer full): A #MongoBson.
- */
-MongoBson *
-mongo_bson_iter_get_value_array (MongoBsonIter *iter)
-{
- MongoBson *ret;
-
- ENTRY;
- ret = mongo_bson_iter_get_value_document(iter, MONGO_BSON_ARRAY);
- RETURN(ret);
-}
-
-/**
- * mongo_bson_iter_get_value_boolean:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the current value pointed to by the iterator, expecting it to
- * be a boolean.
- *
- * Returns: The current value.
- */
-gboolean
-mongo_bson_iter_get_value_boolean (MongoBsonIter *iter)
-{
- guint8 b;
-
- ENTRY;
-
- g_return_val_if_fail(iter, 0);
- g_return_val_if_fail(iter->user_data6, 0);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_BOOLEAN)) {
- memcpy(&b, iter->user_data6, sizeof b);
- RETURN(!!b);
- } else if (ITER_IS_TYPE(iter, MONGO_BSON_INT32)) {
- b = !!mongo_bson_iter_get_value_int(iter);
- RETURN(b);
- } else if (ITER_IS_TYPE(iter, MONGO_BSON_INT64)) {
- b = !!mongo_bson_iter_get_value_int64(iter);
- RETURN(b);
- } else if (ITER_IS_TYPE(iter, MONGO_BSON_DOUBLE)) {
- b = (mongo_bson_iter_get_value_double(iter) == 1.0);
- RETURN(b);
- }
-
- g_warning("Current key cannot be coerced to boolean.");
-
- RETURN(FALSE);
-}
-
-/**
- * mongo_bson_iter_get_value_bson:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the current value pointed to by @iter if it is a
- * %MONGO_BSON_DOCUMENT. The document is copied and returned as a new
- * #MongoBson instance. If you simply need to iterate the child document,
- * you may want to use mongo_bson_iter_recurse().
- *
- * Returns: (transfer full): A #MongoBson if successful; otherwise %NULL.
- */
-MongoBson *
-mongo_bson_iter_get_value_bson (MongoBsonIter *iter)
-{
- MongoBson *ret;
-
- ENTRY;
- ret = mongo_bson_iter_get_value_document(iter, MONGO_BSON_DOCUMENT);
- RETURN(ret);
-}
-
-#if GLIB_CHECK_VERSION(2, 26, 0)
-/**
- * mongo_bson_iter_get_value_date_time:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches a #GDateTime for the current value pointed to by @iter.
- *
- * Returns: A new #GDateTime which should be freed with g_date_time_unref().
- */
-GDateTime *
-mongo_bson_iter_get_value_date_time (MongoBsonIter *iter)
-{
- GTimeVal tv;
-
- g_return_val_if_fail(iter != NULL, NULL);
-
- mongo_bson_iter_get_value_timeval(iter, &tv);
- return g_date_time_new_from_timeval_utc(&tv);
-}
-#endif
-
-/**
- * mongo_bson_iter_get_value_double:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the current value pointed to by @iter if it is a
- * %MONGO_BSON_DOUBLE.
- *
- * Returns: A #gdouble.
- */
-gdouble
-mongo_bson_iter_get_value_double (MongoBsonIter *iter)
-{
- gdouble value;
-
- g_return_val_if_fail(iter != NULL, 0);
- g_return_val_if_fail(iter->user_data6 != NULL, 0);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_DOUBLE)) {
- memcpy(&value, iter->user_data6, sizeof value);
- return value;
- }
-
- g_warning("Current value is not a double.");
-
- return 0.0;
-}
-
-/**
- * mongo_bson_iter_get_value_object_id:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the current value pointed to by @iter if it is a
- * %MONGO_BSON_OBJECT_ID. The resulting #MongoObjectId should be freed
- * with mongo_object_id_free().
- *
- * Returns: (transfer full): A #MongoObjectId.
- */
-MongoObjectId *
-mongo_bson_iter_get_value_object_id (MongoBsonIter *iter)
-{
- g_return_val_if_fail(iter != NULL, NULL);
- g_return_val_if_fail(iter->user_data6 != NULL, NULL);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_OBJECT_ID)) {
- return mongo_object_id_new_from_data(iter->user_data6);
- }
-
- g_warning("Current value is not an ObjectId.");
-
- return NULL;
-}
-
-/**
- * mongo_bson_iter_get_value_int:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the current value pointed to by @iter if it is a
- * %MONGO_BSON_INT32.
- *
- * Returns: A #gint32 containing the value.
- */
-gint32
-mongo_bson_iter_get_value_int (MongoBsonIter *iter)
-{
- gint32 value;
-
- g_return_val_if_fail(iter != NULL, 0);
- g_return_val_if_fail(iter->user_data6 != NULL, 0);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_INT32)) {
- memcpy(&value, iter->user_data6, sizeof value);
- return GINT_FROM_LE(value);
- }
-
- g_warning("Current value is not an int32.");
-
- return 0;
-}
-
-/**
- * mongo_bson_iter_get_value_int64:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the current value pointed to by @iter if it is a
- * %MONGO_BSON_INT64.
- *
- * Returns: A #gint64.
- */
-gint64
-mongo_bson_iter_get_value_int64 (MongoBsonIter *iter)
-{
- gint64 value;
-
- g_return_val_if_fail(iter != NULL, 0L);
- g_return_val_if_fail(iter->user_data6 != NULL, 0L);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_INT64)) {
- memcpy(&value, iter->user_data6, sizeof value);
- return GINT64_FROM_LE(value);
- }
-
- g_warning("Current value is not an int64.");
-
- return 0L;
-}
-
-/**
- * mongo_bson_iter_get_value_regex:
- * @iter: (in): A #MongoBsonIter.
- * @regex: (out) (allow-none) (transfer none): A location for a string containing the regex.
- * @options: (out) (allow-none) (transfer none): A location for a string containing the options.
- *
- * Fetches the current value pointed to by @iter if it is a regex. The values
- * MUST NOT be modified or freed.
- */
-void
-mongo_bson_iter_get_value_regex (MongoBsonIter *iter,
- const gchar **regex,
- const gchar **options)
-{
- g_return_if_fail(iter != NULL);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_REGEX)) {
- if (regex) {
- *regex = iter->user_data6;
- }
- if (options) {
- *options = iter->user_data7;
- }
- return;
- }
-
- g_warning("Current value is not a Regex.");
-}
-
-/**
- * mongo_bson_iter_get_value_string:
- * @iter: (in): A #MongoBsonIter.
- * @length: (out) (allow-none): The length of the resulting string.
- *
- * Fetches the current value pointed to by @iter if it is a
- * %MONGO_BSON_UTF8. If @length is not %NULL, then the length of the
- * string will be stored in the location pointed to by @length.
- *
- * Returns: A string which should not be modified or freed.
- */
-const gchar *
-mongo_bson_iter_get_value_string (MongoBsonIter *iter,
- gsize *length)
-{
- gint32 real_length;
-
- g_return_val_if_fail(iter != NULL, NULL);
- g_return_val_if_fail(iter->user_data6 != NULL, NULL);
- g_return_val_if_fail(iter->user_data7 != NULL, NULL);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_UTF8)) {
- if (length) {
- memcpy(&real_length, iter->user_data6, sizeof real_length);
- if ((iter->flags & ITER_INVALID_UTF8)) {
- *length = strlen(iter->user_data7) + 1;
- } else {
- *length = GINT_FROM_LE(real_length);
- }
-
- }
- return iter->user_data7;
- }
-
- g_warning("Current value is not a String");
-
- return NULL;
-}
-
-/**
- * mongo_bson_iter_get_value_timeval:
- * @iter: (in): A #MongoBsonIter.
- * @value: (out): A location for a #GTimeVal.
- *
- * Fetches the current value pointed to by @iter as a #GTimeVal if the type
- * is a %MONGO_BSON_DATE_TIME.
- */
-void
-mongo_bson_iter_get_value_timeval (MongoBsonIter *iter,
- GTimeVal *value)
-{
- gint64 v_int64;
-
- g_return_if_fail(iter != NULL);
- g_return_if_fail(value != NULL);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_DATE_TIME)) {
- memcpy(&v_int64, iter->user_data6, sizeof v_int64);
- v_int64 = GINT64_FROM_LE(v_int64);
- value->tv_sec = v_int64 / 1000;
- value->tv_usec = v_int64 % 1000;
- return;
- }
-
- g_warning("Current value is not a DateTime");
-}
-
-/**
- * mongo_bson_iter_get_value_type:
- * @iter: (in): A #MongoBsonIter.
- *
- * Fetches the #MongoBsonType currently pointed to by @iter.
- *
- * Returns: A #MongoBsonType.
- */
-MongoBsonType
-mongo_bson_iter_get_value_type (MongoBsonIter *iter)
-{
- MongoBsonType type;
-
- g_return_val_if_fail(iter != NULL, 0);
- g_return_val_if_fail(iter->user_data5 != NULL, 0);
-
- type = GPOINTER_TO_INT(iter->user_data5);
-
- switch (type) {
- case MONGO_BSON_DOUBLE:
- case MONGO_BSON_UTF8:
- case MONGO_BSON_DOCUMENT:
- case MONGO_BSON_ARRAY:
- case MONGO_BSON_UNDEFINED:
- case MONGO_BSON_OBJECT_ID:
- case MONGO_BSON_BOOLEAN:
- case MONGO_BSON_DATE_TIME:
- case MONGO_BSON_NULL:
- case MONGO_BSON_REGEX:
- case MONGO_BSON_INT32:
- case MONGO_BSON_INT64:
- return type;
- default:
- g_warning("Unknown BSON type 0x%02x", type);
- return 0;
- }
-}
-
-/**
- * mongo_bson_iter_is_key:
- * @iter: (in): A #MongoBsonIter.
- * @key: (in): The key to check for.
- *
- * Checks to see if the iterator is on the given key.
- *
- * Returns: %TRUE if @iter is observing @key.
- */
-gboolean
-mongo_bson_iter_is_key (MongoBsonIter *iter,
- const gchar *key)
-{
- const gchar *current_key;
-
- g_return_val_if_fail(iter, FALSE);
- g_return_val_if_fail(key, FALSE);
-
- current_key = mongo_bson_iter_get_key(iter);
- return !g_strcmp0(key, current_key);
-}
-
-/**
- * mongo_bson_iter_recurse:
- * @iter: (in): A #MongoBsonIter.
- * @child: (out): A #MongoBsonIter.
- *
- * Recurses into the child BSON document found at the key currently observed
- * by the #MongoBsonIter. The @child #MongoBsonIter is initialized.
- *
- * Returns: %TRUE if @child is initialized; otherwise %FALSE.
- */
-gboolean
-mongo_bson_iter_recurse (MongoBsonIter *iter,
- MongoBsonIter *child)
-{
- gint32 buflen;
-
- g_return_val_if_fail(iter != NULL, FALSE);
- g_return_val_if_fail(iter != NULL, FALSE);
- g_return_val_if_fail(child != NULL, FALSE);
-
- if (ITER_IS_TYPE(iter, MONGO_BSON_ARRAY) ||
- ITER_IS_TYPE(iter, MONGO_BSON_DOCUMENT)) {
- memset(child, 0, sizeof *child);
- memcpy(&buflen, iter->user_data6, sizeof buflen);
- child->user_data1 = iter->user_data6;
- child->user_data2 = GINT_TO_POINTER(GINT_FROM_LE(buflen));
- child->user_data3 = GINT_TO_POINTER(3); /* End of size buffer */
- return TRUE;
- }
-
- g_warning("Current value is not a BSON document or array.");
-
- return FALSE;
-}
-
-static inline guint
-first_nul (const gchar *data,
- guint max_bytes)
-{
- guint i;
-
- for (i = 0; i < max_bytes; i++) {
- if (!data[i]) {
- return i;
- }
- }
-
- return 0;
-}
-
-/**
- * mongo_bson_iter_next:
- * @iter: (inout): A #MongoBsonIter.
- *
- * Moves @iter to the next field in the document. If no more fields exist,
- * then %FALSE is returned.
- *
- * Returns: %FALSE if there are no more fields or an error; otherwise %TRUE.
- */
-gboolean
-mongo_bson_iter_next (MongoBsonIter *iter)
-{
- const guint8 *rawbuf;
- gsize rawbuf_len;
- gsize offset;
- const gchar *key;
- MongoBsonType type;
- const guint8 *value1;
- const guint8 *value2;
- const gchar *end = NULL;
- guint32 max_len;
-
- ENTRY;
-
- g_return_val_if_fail(iter, FALSE);
-
- /*
- * Copy values onto stack from iter.
- */
- rawbuf = iter->user_data1;
- rawbuf_len = GPOINTER_TO_SIZE(iter->user_data2);
- offset = GPOINTER_TO_SIZE(iter->user_data3);
- key = (const gchar *)iter->user_data4;
- type = GPOINTER_TO_INT(iter->user_data5);
- value1 = (const guint8 *)iter->user_data6;
- value2 = (const guint8 *)iter->user_data7;
-
- /*
- * Unset the invalid utf8 field.
- */
- iter->flags &= ~ITER_INVALID_UTF8;
-
- /*
- * Check for end of buffer.
- */
- if ((offset + 1) >= rawbuf_len) {
- GOTO(failure);
- }
-
- /*
- * Get the type of the next field.
- */
- if (!(type = rawbuf[++offset])) {
- /*
- * This is the end of the iterator.
- */
- GOTO(failure);
- }
-
- /*
- * Get the key of the next field.
- */
- key = (const gchar *)&rawbuf[++offset];
- max_len = first_nul(key, rawbuf_len - offset - 1);
- if (!(iter->flags & ITER_TRUST_UTF8)) {
- if (!g_utf8_validate(key, max_len, &end)) {
- GOTO(failure);
- }
- }
- offset += strlen(key) + 1;
-
- switch (type) {
- case MONGO_BSON_UTF8:
- if ((offset + 5) < rawbuf_len) {
- value1 = &rawbuf[offset];
- offset += 4;
- value2 = &rawbuf[offset];
- max_len = GUINT32_FROM_LE(*(guint32 *)value1);
- if ((offset + max_len - 10) < rawbuf_len) {
- if (!(iter->flags & ITER_TRUST_UTF8)) {
- if ((end = (char *)u8_check((guint8 *)value2, max_len - 1))) {
- /*
- * Well, we have quite the delima here. The UTF-8 string is
- * invalid, but there was definitely a key here. Consumers
- * might need to get at data after this too. So the best
- * we can do is probably set the value to as long of a valid
- * utf-8 string as we can. We will simply NULL the end of
- * the buffer at the given error offset.
- */
- *(gchar *)end = '\0';
- offset += max_len - 1;
- iter->flags |= ITER_INVALID_UTF8;
- GOTO(success);
- }
- }
- offset += max_len - 1;
- if (value2[max_len - 1] == '\0') {
- GOTO(success);
- }
- }
- }
- GOTO(failure);
- case MONGO_BSON_DOCUMENT:
- case MONGO_BSON_ARRAY:
- if ((offset + 5) < rawbuf_len) {
- value1 = &rawbuf[offset];
- value2 = NULL;
- memcpy(&max_len, value1, sizeof max_len);
- max_len = GUINT32_FROM_LE(max_len);
- if ((offset + max_len) <= rawbuf_len) {
- offset += max_len - 1;
- GOTO(success);
- }
- }
- GOTO(failure);
- case MONGO_BSON_NULL:
- case MONGO_BSON_UNDEFINED:
- value1 = NULL;
- value2 = NULL;
- offset--;
- GOTO(success);
- case MONGO_BSON_OBJECT_ID:
- if ((offset + 12) < rawbuf_len) {
- value1 = &rawbuf[offset];
- value2 = NULL;
- offset += 11;
- GOTO(success);
- }
- GOTO(failure);
- case MONGO_BSON_BOOLEAN:
- if ((offset + 1) < rawbuf_len) {
- value1 = &rawbuf[offset];
- value2 = NULL;
- GOTO(success);
- }
- GOTO(failure);
- case MONGO_BSON_DATE_TIME:
- case MONGO_BSON_DOUBLE:
- case MONGO_BSON_INT64:
- if ((offset + 8) < rawbuf_len) {
- value1 = &rawbuf[offset];
- value2 = NULL;
- offset += 7;
- GOTO(success);
- }
- GOTO(failure);
- case MONGO_BSON_REGEX:
- value1 = &rawbuf[offset];
- max_len = first_nul((gchar *)value1, rawbuf_len - offset - 1);
- if (!(iter->flags & ITER_TRUST_UTF8)) {
- if (!g_utf8_validate((gchar *)value1, max_len, &end)) {
- GOTO(failure);
- }
- }
- offset += max_len + 1;
- if ((offset + 1) >= rawbuf_len) {
- GOTO(failure);
- }
- value2 = &rawbuf[offset];
- max_len = first_nul((gchar *)value2, rawbuf_len - offset - 1);
- if (!(iter->flags & ITER_TRUST_UTF8)) {
- if (!g_utf8_validate((gchar *)value2, max_len, &end)) {
- GOTO(failure);
- }
- }
- offset += max_len + 1;
- GOTO(success);
- case MONGO_BSON_INT32:
- if ((offset + 4) < rawbuf_len) {
- value1 = &rawbuf[offset];
- value2 = NULL;
- offset += 3;
- GOTO(success);
- }
- GOTO(failure);
- default:
- g_warning("Unknown type: %d key: %s", type, key);
- GOTO(failure);
- }
-
-success:
- iter->user_data3 = GSIZE_TO_POINTER(offset);
- iter->user_data4 = (gpointer)key;
- iter->user_data5 = GINT_TO_POINTER(type);
- iter->user_data6 = (gpointer)value1;
- iter->user_data7 = (gpointer)value2;
- RETURN(TRUE);
-
-failure:
- memset(iter, 0, sizeof *iter);
- RETURN(FALSE);
-}
-
-/**
- * mongo_clear_bson:
- * @bson: (inout) (allow-none): A pointer to a #MongoBson or %NULL.
- *
- * If @bson is a pointer to a #MongoBson, it will be freed and zeroed.
- */
-void
-mongo_clear_bson (MongoBson **bson)
-{
- if (bson && *bson) {
- mongo_bson_unref(*bson);
- *bson = NULL;
- }
-}
-
-/**
- * mongo_bson_to_string:
- * @bson: A #MongoBson.
- * @is_array: If the document should be generated as an array.
- *
- * Build a string representing the BSON document. Since BSON documents are
- * used for both documents and arrays, you can change the format using
- * @is_array.
- *
- * Returns: (transfer full): A string representing the BSON document.
- */
-gchar *
-mongo_bson_to_string (const MongoBson *bson,
- gboolean is_array)
-{
- MongoBsonIter iter;
- MongoBsonType type;
- GString *str;
- gchar *esc;
-
-
- g_return_val_if_fail(bson, NULL);
-
- str = g_string_new(is_array ? "[" : "{");
-
- mongo_bson_iter_init(&iter, bson);
- if (mongo_bson_iter_next(&iter)) {
-again:
- if (!is_array) {
- esc = g_strescape(mongo_bson_iter_get_key(&iter), NULL);
- g_string_append_printf(str, "\"%s\": ", esc);
- g_free(esc);
-
- }
- type = mongo_bson_iter_get_value_type(&iter);
- switch (type) {
- case MONGO_BSON_DOUBLE:
- g_string_append_printf(str, "%f",
- mongo_bson_iter_get_value_double(&iter));
- break;
- case MONGO_BSON_DATE_TIME:
- {
- GTimeVal tv = { 0 };
- gchar *dstr;
-
- mongo_bson_iter_get_value_timeval(&iter, &tv);
- dstr = g_time_val_to_iso8601(&tv);
- g_string_append_printf(str, "ISODate(\"%s\")", dstr);
- g_free(dstr);
- }
- break;
- case MONGO_BSON_INT32:
- g_string_append_printf(str, "NumberLong(%d)",
- mongo_bson_iter_get_value_int(&iter));
- break;
- case MONGO_BSON_INT64:
- g_string_append_printf(str, "NumberLong(%"G_GINT64_FORMAT")",
- mongo_bson_iter_get_value_int64(&iter));
- break;
- case MONGO_BSON_UTF8:
- esc = g_strescape(mongo_bson_iter_get_value_string(&iter, NULL), NULL);
- g_string_append_printf(str, "\"%s\"", esc);
- g_free(esc);
- break;
- case MONGO_BSON_ARRAY:
- {
- MongoBson *child;
- gchar *childstr;
-
- if ((child = mongo_bson_iter_get_value_array(&iter))) {
- childstr = mongo_bson_to_string(child, TRUE);
- g_string_append(str, childstr);
- mongo_bson_unref(child);
- g_free(childstr);
- }
- }
- break;
- case MONGO_BSON_DOCUMENT:
- {
- MongoBson *child;
- gchar *childstr;
-
- if ((child = mongo_bson_iter_get_value_bson(&iter))) {
- childstr = mongo_bson_to_string(child, FALSE);
- g_string_append(str, childstr);
- mongo_bson_unref(child);
- g_free(childstr);
- }
- }
- break;
- case MONGO_BSON_BOOLEAN:
- g_string_append_printf(str,
- mongo_bson_iter_get_value_boolean(&iter) ? "true" : "false");
- break;
- case MONGO_BSON_OBJECT_ID:
- {
- MongoObjectId *id;
- gchar *idstr;
-
- id = mongo_bson_iter_get_value_object_id(&iter);
- idstr = mongo_object_id_to_string(id);
- g_string_append_printf(str, "ObjectId(\"%s\")", idstr);
- mongo_object_id_free(id);
- g_free(idstr);
- }
- break;
- case MONGO_BSON_NULL:
- g_string_append(str, "null");
- break;
- case MONGO_BSON_REGEX:
- /* TODO: */
- g_assert_not_reached();
- break;
- case MONGO_BSON_UNDEFINED:
- g_string_append(str, "undefined");
- break;
- default:
- g_assert_not_reached();
- }
-
- if (mongo_bson_iter_next(&iter)) {
- g_string_append(str, ", ");
- goto again;
- }
- }
-
- g_string_append(str, is_array ? "]" : "}");
-
- return g_string_free(str, FALSE);
-}
-
-/**
- * mongo_bson_join:
- * @bson: (in): A #MongoBson.
- * @other: (in): A #MongoBson.
- *
- * Appends the contents of @other to the end of @bson.
- */
-void
-mongo_bson_join (MongoBson *bson,
- const MongoBson *other)
-{
- const guint8 *other_data;
- guint32 new_size;
- gsize other_len;
- guint offset;
-
- g_return_if_fail(bson);
- g_return_if_fail(other);
-
- if (!bson->buf) {
- g_warning("Cannot join BSON document to static BSON.");
- return;
- }
-
- g_assert(bson->buf->len >= 5);
-
- other_data = mongo_bson_get_data(other, &other_len);
- g_assert_cmpint(other_len, >=, 5);
-
- offset = bson->buf->len - 1;
- g_byte_array_set_size(bson->buf, bson->buf->len + other_len - 5);
- memcpy(&bson->buf->data[offset], other_data + 4, other_len - 4);
-
- new_size = GUINT32_TO_LE(bson->buf->len);
- memcpy(bson->buf->data, &new_size, sizeof new_size);
-}
+++ /dev/null
-/* mongo-bson.h
- *
- * Copyright (C) 2011 Christian Hergert <christian@catch.com>
- *
- * This file 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 file 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 General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if !defined (MONGO_INSIDE) && !defined (MONGO_COMPILATION)
-#error "Only <mongo-glib/mongo-glib.h> can be included directly."
-#endif
-
-#ifndef MONGO_BSON_H
-#define MONGO_BSON_H
-
-#include <glib-object.h>
-
-#include "mongo-object-id.h"
-
-G_BEGIN_DECLS
-
-#define MONGO_TYPE_BSON (mongo_bson_get_type())
-#define MONGO_TYPE_BSON_TYPE (mongo_bson_type_get_type())
-
-/**
- * MONGO_BSON_ITER_HOLDS:
- * @b: A #MongoBsonIter.
- * @t: A #MongoBsonType.
- *
- * Checks to see if @b is pointing at a field of type @t. This is
- * syntacticaly the same as checking the fields value type with
- * mongo_bson_iter_get_value_type().
- *
- * Returns: %TRUE if @b holds the requested type.
- */
-#define MONGO_BSON_ITER_HOLDS(b,t) \
- (mongo_bson_iter_get_value_type((b)) == t)
-
-/**
- * MONGO_BSON_ITER_HOLDS_DOUBLE:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_DOUBLE.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_DOUBLE(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_DOUBLE))
-
-/**
- * MONGO_BSON_ITER_HOLDS_UTF8:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_UTF8.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_UTF8(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_UTF8))
-
-/**
- * MONGO_BSON_ITER_HOLDS_DOCUMENT:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_DOCUMENT.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_DOCUMENT(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_DOCUMENT))
-
-/**
- * MONGO_BSON_ITER_HOLDS_ARRAY:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_ARRAY.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_ARRAY(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_ARRAY))
-
-/**
- * MONGO_BSON_ITER_HOLDS_UNDEFINED:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_UNDEFINED.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_UNDEFINED(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_UNDEFINED))
-
-/**
- * MONGO_BSON_ITER_HOLDS_OBJECT_ID:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_OBJECT_ID.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_OBJECT_ID(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_OBJECT_ID))
-
-/**
- * MONGO_BSON_ITER_HOLDS_BOOLEAN:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_BOOLEAN.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_BOOLEAN(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_BOOLEAN))
-
-/**
- * MONGO_BSON_ITER_HOLDS_DATE_TIME:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_DATE_TIME.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_DATE_TIME(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_DATE_TIME))
-
-/**
- * MONGO_BSON_ITER_HOLDS_NULL:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_NULL.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_NULL(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_NULL))
-
-/**
- * MONGO_BSON_ITER_HOLDS_REGEX:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_REGEX.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_REGEX(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_REGEX))
-
-/**
- * MONGO_BSON_ITER_HOLDS_INT32:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_INT32.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_INT32(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_INT32))
-
-/**
- * MONGO_BSON_ITER_HOLDS_INT64:
- * @b: A #MongoBsonIter.
- *
- * Checks to see if @b is pointing at a field of type %MONGO_BSON_INT64.
- *
- * Returns: %TRUE if the type matches.
- */
-#define MONGO_BSON_ITER_HOLDS_INT64(b) \
- (MONGO_BSON_ITER_HOLDS(b, MONGO_BSON_INT64))
-
-typedef struct _MongoBson MongoBson;
-
-/**
- * MongoBsonType:
- * @MONGO_BSON_DOUBLE: Field contains a #gdouble.
- * @MONGO_BSON_UTF8: Field contains a UTF-8 string.
- * @MONGO_BSON_DOCUMENT: Field contains a BSON document.
- * @MONGO_BSON_ARRAY: Field contains a BSON array.
- * @MONGO_BSON_UNDEFINED: Field is JavaScript undefined.
- * @MONGO_BSON_OBJECT_ID: Field contains a #MongoObjectId.
- * @MONGO_BSON_BOOLEAN: Field contains a #gboolean.
- * @MONGO_BSON_DATE_TIME: Field contains a #GDateTime.
- * @MONGO_BSON_NULL: Field contains %NULL.
- * @MONGO_BSON_REGEX: Field contains a #GRegex.
- * @MONGO_BSON_INT32: Field contains a #gint32.
- * @MONGO_BSON_INT64: Field contains a #gint64.
- *
- * These enumerations specify the field type within a #MongoBson.
- * The field type can be retrieved with mongo_bson_iter_get_value_type().
- */
-typedef enum
-{
- MONGO_BSON_DOUBLE = 0x01,
- MONGO_BSON_UTF8 = 0x02,
- MONGO_BSON_DOCUMENT = 0x03,
- MONGO_BSON_ARRAY = 0x04,
- MONGO_BSON_UNDEFINED = 0x06,
- MONGO_BSON_OBJECT_ID = 0x07,
- MONGO_BSON_BOOLEAN = 0x08,
- MONGO_BSON_DATE_TIME = 0x09,
- MONGO_BSON_NULL = 0x0A,
- MONGO_BSON_REGEX = 0x0B,
- MONGO_BSON_INT32 = 0x10,
- MONGO_BSON_INT64 = 0x12,
-} MongoBsonType;
-
-/**
- * MongoBsonIter:
- *
- * #MongoBsonIter is used to iterate through the contents of a #MongoBson.
- * It is meant to be used on the stack and can allow for reading data
- * directly out of the #MongoBson without having to malloc a copy. This
- * can be handy when dealing with lots of medium to large sized documents.
- */
-typedef struct
-{
- /*< private >*/
- gpointer user_data1; /* Raw data buffer */
- gpointer user_data2; /* Raw buffer length */
- gpointer user_data3; /* Offset */
- gpointer user_data4; /* Key */
- gpointer user_data5; /* Type */
- gpointer user_data6; /* Value1 */
- gpointer user_data7; /* Value2 */
- gint32 flags;
-} MongoBsonIter;
-
-GType mongo_bson_get_type (void) G_GNUC_CONST;
-GType mongo_bson_type_get_type (void) G_GNUC_CONST;
-const guint8 *mongo_bson_get_data (const MongoBson *bson,
- gsize *length);
-gsize mongo_bson_get_size (const MongoBson *bson);
-MongoBson *mongo_bson_new (void);
-MongoBson *mongo_bson_new_empty (void);
-MongoBson *mongo_bson_new_from_data (const guint8 *buffer,
- gsize length);
-MongoBson *mongo_bson_new_take_data (guint8 *buffer,
- gsize length);
-MongoBson *mongo_bson_new_from_static_data (guint8 *buffer,
- gsize length,
- GDestroyNotify notify);
-MongoBson *mongo_bson_dup (const MongoBson *bson);
-MongoBson *mongo_bson_ref (MongoBson *bson);
-void mongo_bson_unref (MongoBson *bson);
-void mongo_bson_append_array (MongoBson *bson,
- const gchar *key,
- MongoBson *value);
-void mongo_bson_append_boolean (MongoBson *bson,
- const gchar *key,
- gboolean value);
-void mongo_bson_append_bson (MongoBson *bson,
- const gchar *key,
- const MongoBson *value);
-#if GLIB_CHECK_VERSION(2, 26, 0)
-void mongo_bson_append_date_time (MongoBson *bson,
- const gchar *key,
- GDateTime *value);
-#endif
-void mongo_bson_append_double (MongoBson *bson,
- const gchar *key,
- gdouble value);
-void mongo_bson_append_int (MongoBson *bson,
- const gchar *key,
- gint32 value);
-void mongo_bson_append_int64 (MongoBson *bson,
- const gchar *key,
- gint64 value);
-void mongo_bson_append_null (MongoBson *bson,
- const gchar *key);
-void mongo_bson_append_object_id (MongoBson *bson,
- const gchar *key,
- const MongoObjectId *object_id);
-void mongo_bson_append_regex (MongoBson *bson,
- const gchar *key,
- const gchar *regex,
- const gchar *options);
-void mongo_bson_append_string (MongoBson *bson,
- const gchar *key,
- const gchar *value);
-void mongo_bson_append_timeval (MongoBson *bson,
- const gchar *key,
- GTimeVal *value);
-void mongo_bson_append_undefined (MongoBson *bson,
- const gchar *key);
-gboolean mongo_bson_get_empty (MongoBson *bson);
-void mongo_bson_join (MongoBson *bson,
- const MongoBson *other);
-void mongo_bson_iter_init (MongoBsonIter *iter,
- const MongoBson *bson);
-gboolean mongo_bson_iter_find (MongoBsonIter *iter,
- const gchar *key);
-const gchar *mongo_bson_iter_get_key (MongoBsonIter *iter);
-MongoBson *mongo_bson_iter_get_value_array (MongoBsonIter *iter);
-gboolean mongo_bson_iter_get_value_boolean (MongoBsonIter *iter);
-MongoBson *mongo_bson_iter_get_value_bson (MongoBsonIter *iter);
-#if GLIB_CHECK_VERSION(2, 26, 0)
-GDateTime *mongo_bson_iter_get_value_date_time (MongoBsonIter *iter);
-#endif
-gdouble mongo_bson_iter_get_value_double (MongoBsonIter *iter);
-MongoObjectId *mongo_bson_iter_get_value_object_id (MongoBsonIter *iter);
-gint32 mongo_bson_iter_get_value_int (MongoBsonIter *iter);
-gint64 mongo_bson_iter_get_value_int64 (MongoBsonIter *iter);
-void mongo_bson_iter_get_value_regex (MongoBsonIter *iter,
- const gchar **regex,
- const gchar **options);
-const gchar *mongo_bson_iter_get_value_string (MongoBsonIter *iter,
- gsize *length);
-void mongo_bson_iter_get_value_timeval (MongoBsonIter *iter,
- GTimeVal *value);
-MongoBsonType mongo_bson_iter_get_value_type (MongoBsonIter *iter);
-gboolean mongo_bson_iter_is_key (MongoBsonIter *iter,
- const gchar *key);
-gboolean mongo_bson_iter_next (MongoBsonIter *iter);
-gboolean mongo_bson_iter_recurse (MongoBsonIter *iter,
- MongoBsonIter *child);
-void mongo_bson_iter_set_trust_utf8 (MongoBsonIter *iter,
- gboolean trust_utf8);
-gchar *mongo_bson_to_string (const MongoBson *bson,
- gboolean is_array);
-void mongo_clear_bson (MongoBson **bson);
-
-
-G_END_DECLS
-
-#endif /* MONGO_BSON_H */
-
+++ /dev/null
-/* mongo-object-id.c
- *
- * Copyright (C) 2011 Christian Hergert <christian@catch.com>
- *
- * This file 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 file 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 General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "maru_common.h"
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#ifdef CONFIG_WIN32
-#include <windows.h>
-#include <winsock2.h>
-#endif
-#include "mongo-object-id.h"
-
-#ifndef HOST_NAME_MAX
-#define HOST_NAME_MAX 256
-#endif
-
-/**
- * SECTION:mongo-object-id
- * @title: MongoObjectId
- * @short_description: ObjectId structure used by BSON and Mongo.
- *
- * #MongoObjectId represents an ObjectId as used by the BSON serialization
- * format and Mongo. It is a 12-byte structure designed in a way to allow
- * client side generation of unique object identifiers. The first 4 bytes
- * contain the UNIX timestamp since January 1, 1970. The following 3 bytes
- * contain the first 3 bytes of the hostname MD5 hashed. Following that are
- * 2 bytes containing the Process ID or Thread ID. The last 3 bytes contain
- * a continually incrementing counter.
- *
- * When creating a new #MongoObjectId using mongo_object_id_new(), all of
- * this data is created for you.
- *
- * To create a #MongoObjectId from an existing 12 bytes, use
- * mongo_object_id_new_from_data().
- *
- * To free an allocated #MongoObjectId, use mongo_object_id_free().
- */
-
-struct _MongoObjectId
-{
- guint8 data[12];
-};
-
-static guint8 gMachineId[3];
-static gushort gPid;
-static gint32 gIncrement;
-
-static void
-mongo_object_id_init (void)
-{
- gchar hostname[HOST_NAME_MAX] = { 0 };
- char *md5;
- int ret;
-
- if (0 != (ret = gethostname(hostname, sizeof hostname - 1))) {
- g_error("Failed to get hostname, cannot generate MongoObjectId");
- }
-
- md5 = g_compute_checksum_for_string(G_CHECKSUM_MD5, hostname,
- sizeof hostname);
- memcpy(gMachineId, md5, sizeof gMachineId);
- g_free(md5);
-
- gPid = (gushort)getpid();
-}
-
-/**
- * mongo_object_id_new:
- *
- * Create a new #MongoObjectId. The timestamp, PID, hostname, and counter
- * fields of the #MongoObjectId will be generated.
- *
- * Returns: (transfer full): A #MongoObjectId that should be freed with
- * mongo_object_id_free().
- */
-MongoObjectId *
-mongo_object_id_new (void)
-{
- static gsize initialized = FALSE;
- GTimeVal val = { 0 };
- guint32 t;
- guint8 bytes[12];
- gint32 inc;
-
- if (g_once_init_enter(&initialized)) {
- mongo_object_id_init();
- g_once_init_leave(&initialized, TRUE);
- }
-
- g_get_current_time(&val);
- t = GUINT32_TO_BE(val.tv_sec);
- if(!GLIB_CHECK_VERSION(2, 30, 0)) {
- inc = GUINT32_TO_BE(g_atomic_int_add(&gIncrement, 1));
- }
- else {
- inc = GUINT32_TO_BE(g_atomic_int_exchange_and_add(&gIncrement, 1));
- }
-
- memcpy(&bytes[0], &t, sizeof t);
- memcpy(&bytes[4], &gMachineId, sizeof gMachineId);
- memcpy(&bytes[7], &gPid, sizeof gPid);
- bytes[9] = ((guint8 *)&inc)[1];
- bytes[10] = ((guint8 *)&inc)[2];
- bytes[11] = ((guint8 *)&inc)[3];
-
- return mongo_object_id_new_from_data(bytes);
-}
-
-/**
- * mongo_object_id_new_from_data:
- * @bytes: (array): The bytes containing the object id.
- *
- * Creates a new #MongoObjectId from an array of 12 bytes. @bytes
- * MUST contain 12-bytes.
- *
- * Returns: (transfer full): A newly allocated #MongoObjectId that should
- * be freed with mongo_object_id_free().
- */
-MongoObjectId *
-mongo_object_id_new_from_data (const guint8 *bytes)
-{
- MongoObjectId *object_id;
-
- object_id = g_slice_new0(MongoObjectId);
-
- if (bytes) {
- memcpy(object_id, bytes, sizeof *object_id);
- }
-
- return object_id;
-}
-
-/**
- * mongo_object_id_new_from_string:
- * @string: A 24-character string containing the object id.
- *
- * Creates a new #MongoObjectId from a 24-character, hex-encoded, string.
- *
- * Returns: A newly created #MongoObjectId if successful; otherwise %NULL.
- */
-MongoObjectId *
-mongo_object_id_new_from_string (const gchar *string)
-{
- guint32 v;
- guint8 data[12] = { 0 };
- guint i;
-
- g_return_val_if_fail(string, NULL);
-
- if (strlen(string) != 24) {
- return NULL;
- }
-
- for (i = 0; i < 12; i++) {
- sscanf(&string[i * 2], "%02x", &v);
- data[i] = v;
- }
-
- return mongo_object_id_new_from_data(data);
-}
-
-/**
- * mongo_object_id_to_string:
- * @object_id: (in): A #MongoObjectId.
- *
- * Converts @object_id into a hex string.
- *
- * Returns: (transfer full): The ObjectId as a string.
- */
-gchar *
-mongo_object_id_to_string (const MongoObjectId *object_id)
-{
- GString *str;
- guint i;
-
- g_return_val_if_fail(object_id, NULL);
-
- str = g_string_sized_new(24);
- for (i = 0; i < sizeof object_id->data; i++) {
- g_string_append_printf(str, "%02x", object_id->data[i]);
- }
-
- return g_string_free(str, FALSE);
-}
-
-/**
- * mongo_object_id_copy:
- * @object_id: (in): A #MongoObjectId.
- *
- * Creates a new #MongoObjectId that is a copy of @object_id.
- *
- * Returns: (transfer full): A #MongoObjectId that should be freed with
- * mongo_object_id_free().
- */
-MongoObjectId *
-mongo_object_id_copy (const MongoObjectId *object_id)
-{
- MongoObjectId *copy = NULL;
-
- if (object_id) {
- copy = g_slice_new(MongoObjectId);
- memcpy(copy, object_id, sizeof *object_id);
- }
-
- return copy;
-}
-
-/**
- * mongo_object_id_compare:
- * @object_id: (in): The first #MongoObjectId.
- * @other: (in): The second #MongoObjectId.
- *
- * A qsort() style compare function that will return less than zero
- * if @object_id is less than @other, zero if they are the same, and
- * greater than one if @other is greater than @object_id.
- *
- * Returns: A qsort() style compare integer.
- */
-gint
-mongo_object_id_compare (const MongoObjectId *object_id,
- const MongoObjectId *other)
-{
- return memcmp(object_id, other, sizeof object_id->data);
-}
-
-/**
- * mongo_object_id_equal:
- * @v1: (in): A #MongoObjectId.
- * @v2: (in): A #MongoObjectId.
- *
- * Checks if @v1 and @v2 contain the same object id.
- *
- * Returns: %TRUE if @v1 and @v2 are equal.
- */
-gboolean
-mongo_object_id_equal (gconstpointer v1,
- gconstpointer v2)
-{
- return !mongo_object_id_compare(v1, v2);
-}
-
-/**
- * mongo_object_id_hash:
- * @v: (in): A #MongoObjectId.
- *
- * Hashes the bytes of the provided #MongoObjectId using DJB hash.
- * This is suitable for using as a hash function for #GHashTable.
- *
- * Returns: A hash value corresponding to the key.
- */
-guint
-mongo_object_id_hash (gconstpointer v)
-{
- const MongoObjectId *object_id = v;
- guint hash = 5381;
- guint i;
-
- g_return_val_if_fail(object_id, 5381);
-
- for (i = 0; i < G_N_ELEMENTS(object_id->data); i++) {
- hash = ((hash << 5) + hash) + object_id->data[i];
- }
-
- return hash;
-}
-
-/**
- * mongo_object_id_get_data:
- * @object_id: (in): A #MongoObjectId.
- * @length: (out) (allow-none): Then number of bytes returned.
- *
- * Gets the raw bytes for the object id. The length of the bytes is
- * returned in the out paramter @length for language bindings and
- * is always 12.
- *
- * Returns: (transfer none) (array length=length): The object id bytes.
- */
-const guint8 *
-mongo_object_id_get_data (const MongoObjectId *object_id,
- gsize *length)
-{
- g_return_val_if_fail(object_id, NULL);
- if (length)
- *length = sizeof object_id->data;
- return object_id->data;
-}
-
-/**
- * mongo_object_id_free:
- * @object_id: (in): A #MongoObjectId.
- *
- * Frees a #MongoObjectId.
- */
-void
-mongo_object_id_free (MongoObjectId *object_id)
-{
- if (object_id) {
- g_slice_free(MongoObjectId, object_id);
- }
-}
-
-/**
- * mongo_clear_object_id:
- * @object_id: (out): A pointer to a #MongoObjectId.
- *
- * Clears the pointer to a #MongoObjectId by freeing the #MongoObjectId
- * and then setting the pointer to %NULL. If no #MongoObjectId was found,
- * then no operation is performed.
- */
-void
-mongo_clear_object_id (MongoObjectId **object_id)
-{
- if (object_id && *object_id) {
- mongo_object_id_free(*object_id);
- *object_id = NULL;
- }
-}
-
-/**
- * mongo_object_id_get_type:
- *
- * Fetches the boxed #GType for #MongoObjectId.
- *
- * Returns: A #GType.
- */
-GType
-mongo_object_id_get_type (void)
-{
- static GType type_id = 0;
- static gsize initialized = FALSE;
-
- if (g_once_init_enter(&initialized)) {
- type_id = g_boxed_type_register_static(
- "MongoObjectId",
- (GBoxedCopyFunc)mongo_object_id_copy,
- (GBoxedFreeFunc)mongo_object_id_free);
- g_once_init_leave(&initialized, TRUE);
- }
-
- return type_id;
-}
projects / sdk / emulator / qemu.git / commitdiff