自学教程：C++ G_SEEKABLE函数代码示例

static gint64xmms_gvfs_seek (xmms_xform_t *xform, gint64 offset,                xmms_xform_seek_mode_t whence, xmms_error_t *error){    GSeekType type;    GError *err = NULL;    xmms_gvfs_data_t *data = xmms_xform_private_data_get (xform);    g_return_val_if_fail (data, -1);    g_return_val_if_fail (!g_input_stream_is_closed (data->handle), -1);    switch (whence) {    case XMMS_XFORM_SEEK_CUR:        type = G_SEEK_CUR;        break;    case XMMS_XFORM_SEEK_SET:        type = G_SEEK_SET;        break;    case XMMS_XFORM_SEEK_END:        type = G_SEEK_END;        break;    }    if (g_seekable_seek (G_SEEKABLE (data->handle), offset, type, NULL, &err)) {        return g_seekable_tell (G_SEEKABLE (data->handle));    }    xmms_error_set (error, XMMS_ERROR_GENERIC, err->message);    return -1;}

static gbooleantry_seek_on_read (GVfsBackend *backend,                  GVfsJobSeekRead *job,                  GVfsBackendHandle handle,                  goffset    offset,                  GSeekType  type){  GInputStream    *stream;  GError          *error = NULL;  stream = G_INPUT_STREAM (handle);  if (!g_seekable_seek (G_SEEKABLE (stream), offset, type,                        G_VFS_JOB (job)->cancellable, &error))    {      g_vfs_job_failed_literal (G_VFS_JOB (job),                                error->domain,                                error->code,                                error->message);      g_error_free (error);      return FALSE;    }  else    {      g_vfs_job_seek_read_set_offset (job, g_seekable_tell (G_SEEKABLE (stream)));      g_vfs_job_succeeded (G_VFS_JOB (job));    }  return TRUE;}

static voidextract_gibest_hash (GTask        *task,                     gpointer      source_object,                     gpointer      task_data,                     GCancellable *cancellable){  GFile *file = source_object;  guint64 buffer[2][CHUNK_N_BYTES/8];  GInputStream *stream = NULL;  gssize n_bytes, file_size;  GError *error = NULL;  guint64 hash = 0;  gint i;  char *str;  ResolveData *resolve_data = task_data;  GrlLocalMetadataSourcePriv *priv;  priv = GRL_LOCAL_METADATA_SOURCE_GET_PRIVATE (resolve_data->source);  stream = G_INPUT_STREAM (g_file_read (file, cancellable, &error));  if (stream == NULL)    goto fail;  /* Extract start/end chunks of the file */  n_bytes = g_input_stream_read (stream, buffer[0], CHUNK_N_BYTES, cancellable, &error);  if (n_bytes == -1)    goto fail;  if (!g_seekable_seek (G_SEEKABLE (stream), -CHUNK_N_BYTES, G_SEEK_END, cancellable, &error))    goto fail;  n_bytes = g_input_stream_read (stream, buffer[1], CHUNK_N_BYTES, cancellable, &error);  if (n_bytes == -1)    goto fail;  for (i = 0; i < G_N_ELEMENTS (buffer[0]); i++)    hash += buffer[0][i] + buffer[1][i];  file_size = g_seekable_tell (G_SEEKABLE (stream));  if (file_size < CHUNK_N_BYTES)    goto fail;  /* Include file size */  hash += file_size;  g_object_unref (stream);  str = g_strdup_printf ("%" G_GINT64_FORMAT, hash);  grl_data_set_string (GRL_DATA (resolve_data->rs->media), priv->hash_keyid, str);  g_free (str);  g_task_return_boolean (task, TRUE);  return;fail:  GRL_DEBUG ("Could not get file hash: %s/n", error ? error->message : "Unknown error");  g_task_return_error (task, error);  g_clear_object (&stream);}

static voidddb_gvfs_rewind (DB_FILE *stream){  vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;  g_return_if_fail (data != NULL);  if (g_seekable_can_seek (G_SEEKABLE (data->handle)))    g_seekable_seek (G_SEEKABLE (data->handle), 0, G_SEEK_SET, NULL, NULL);}

ginttest_message_compare (CamelMimeMessage *msg){    CamelMimeMessage *msg2;    CamelStream *stream1;    CamelStream *stream2;    GByteArray *byte_array1;    GByteArray *byte_array2;    byte_array1 = g_byte_array_new ();    stream1 = camel_stream_mem_new_with_byte_array (byte_array1);    check_msg (camel_data_wrapper_write_to_stream_sync (                   CAMEL_DATA_WRAPPER (msg), stream1, NULL, NULL) != -1,               "write_to_stream 1 failed", NULL);    g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);    msg2 = camel_mime_message_new ();    check_msg (camel_data_wrapper_construct_from_stream_sync (                   CAMEL_DATA_WRAPPER (msg2), stream1, NULL, NULL) != -1,               "construct_from_stream 1 failed");    g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);    byte_array2 = g_byte_array_new ();    stream2 = camel_stream_mem_new_with_byte_array (byte_array2);    check_msg (camel_data_wrapper_write_to_stream_sync (                   CAMEL_DATA_WRAPPER (msg2), stream2, NULL, NULL) != -1,               "write_to_stream 2 failed");    g_seekable_seek (G_SEEKABLE (stream2), 0, G_SEEK_SET, NULL, NULL);    if (byte_array1->len != byte_array2->len) {        CamelDataWrapper *content;        printf ("stream1 stream:/n%.*s/n", byte_array1->len, byte_array1->data);        printf ("stream2 stream:/n%.*s/n/n", byte_array2->len, byte_array2->data);        printf ("msg1:/n");        test_message_dump_structure (msg);        printf ("msg2:/n");        test_message_dump_structure (msg2);        content = camel_medium_get_content ((CamelMedium *) msg);    }    check_unref (msg2, 1);    check_msg (        byte_array1->len == byte_array2->len,        "byte_array1->len = %d, byte_array2->len = %d",        byte_array1->len, byte_array2->len);    check_msg (memcmp (byte_array1->data, byte_array2->data, byte_array1->len) == 0, "msg/stream compare");    g_object_unref (stream1);    g_object_unref (stream2);    return 0;}

/* Called from gpgme to seek a file */static off_tvfs_data_seek (void *handle, off_t offset, int whence){    VfsAsyncHandle* ah = (VfsAsyncHandle*)handle;    GSeekable *seekable = NULL;    GSeekType wh;        /* If the file isn't open yet, then do that now */    if (!ah->ostream && !ah->istream && ah->state == VFS_ASYNC_READY)        vfs_data_open_helper (ah);            /* Just in case we have an operation, like open */    if (!vfs_data_wait_results(ah, TRUE))        return (off_t)-1;               g_assert (ah->state == VFS_ASYNC_READY);        if (ah->writer && G_IS_SEEKABLE (ah->ostream))        seekable = G_SEEKABLE (ah->ostream);    else        seekable = G_SEEKABLE (ah->istream);        if (!seekable || !g_seekable_can_seek (seekable)) {        errno = ENOTSUP;        return -1;    }        switch(whence)    {    case SEEK_SET:        wh = G_SEEK_SET;        break;    case SEEK_CUR:        wh = G_SEEK_CUR;        break;    case SEEK_END:        wh = G_SEEK_END;        break;    default:        g_assert_not_reached();        break;    }        /* All seek operations are not async */    g_clear_error (&ah->error);    g_seekable_seek (seekable, (goffset)offset, wh, ah->cancellable, &ah->error);        /* Start async operation */    ah->state = VFS_ASYNC_READY;    if (!vfs_data_wait_results (ah, TRUE))        return -1;        /* Return results */    ah->state = VFS_ASYNC_READY;    return offset;}

static toff_tseek_in_stream(thandle_t handle,               toff_t offset,               int whence){  Priv *p = (Priv*) handle;  GError *error = NULL;  gboolean sought = FALSE;  goffset position = -1;  g_assert(p->stream);  if (p->can_seek)    {      sought = g_seekable_seek(G_SEEKABLE(p->stream),                               (goffset) offset, lseek_to_seek_type(whence),                               NULL, &error);      if (sought)        position = g_seekable_tell(G_SEEKABLE(p->stream));      else        {          g_warning("%s", error->message);          g_error_free(error);        }    }  else    {      switch (whence)        {        default:        case SEEK_SET:          if (offset <= p->allocated)            position = p->position = offset;          break;        case SEEK_CUR:          if (p->position + offset <= p->allocated)            position = p->position += offset;          break;        case G_SEEK_END:          position = p->position = p->allocated + offset;          break;        }    }  return (toff_t) position;}

/** * seahorse_util_read_to_memory: * @input: Data to read. The #GInputStream is read till the end. * @len: Length of the data read (out) * * Reads data from the input stream and returns them as #guchar * * Returns: The string read from data. The returned string should be freed * with #g_free when no longer needed. **/guchar*seahorse_util_read_to_memory (GInputStream *input, guint *len){	gsize size = 128;	gchar *buffer, *text;	gsize nread = 0;	GString *string;	GSeekable *seek;	if (G_IS_SEEKABLE (input)) {		seek = G_SEEKABLE (input);		g_seekable_seek (seek, 0, SEEK_SET, NULL, NULL);	}	string = g_string_new ("");	buffer = g_new (gchar, size);    	while (g_input_stream_read_all (input, buffer, size, &nread, NULL, NULL)) {		string = g_string_append_len (string, buffer, nread);		if (nread != size)			break;	}	if (len)		*len = string->len;    	text = g_string_free (string, FALSE);	g_free (buffer);		return (guchar*)text;}

static voidcache_replace_ready_cb (GObject *source,                        GAsyncResult *res,                        gpointer user_data){  GFileOutputStream *cache_stream;  GError *error = NULL;  NemoPreviewCoverArtFetcher *self = user_data;  cache_stream = g_file_replace_finish (G_FILE (source),                                        res, &error);  if (error != NULL) {    g_warning ("Can't save the cover art image in the cache: %s/n", error->message);    g_error_free (error);    return;  }  g_seekable_seek (G_SEEKABLE (self->priv->input_stream), 0, G_SEEK_SET,                   NULL, NULL);  g_output_stream_splice_async (G_OUTPUT_STREAM (cache_stream),                                 self->priv->input_stream,                                G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |                                G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,                                G_PRIORITY_DEFAULT,                                NULL,                                cache_splice_ready_cb, self);  g_object_unref (cache_stream);}

static gbooleangegl_tile_backend_file_write_header (GeglTileBackendFile *self){  gboolean success;  gegl_tile_backend_file_ensure_exist (self);#if HAVE_GIO  success = g_seekable_seek (G_SEEKABLE (self->o), 0, G_SEEK_SET,                             NULL, NULL);#else  success = (lseek (self->o, 0, SEEK_SET) != -1);#endif  if (success == FALSE)    {      g_warning ("unable to seek in buffer");      return FALSE;    }#if HAVE_GIO  g_output_stream_write (self->o, &(self->header), 256, NULL, NULL);#else  write (self->o, &(self->header), 256);#endif  GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "Wrote header, next=%i", (gint)self->header.next);  return TRUE;}

static gbooleangimp_curves_tool_settings_import (GimpImageMapTool  *image_map_tool,                                  GInputStream      *input,                                  GError           **error){  GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);  gchar           header[64];  gsize           bytes_read;  if (! g_input_stream_read_all (input, header, sizeof (header),                                 &bytes_read, NULL, error) ||      bytes_read != sizeof (header))    {      g_prefix_error (error, _("Could not read header: "));      return FALSE;    }  g_seekable_seek (G_SEEKABLE (input), 0, G_SEEK_SET, NULL, NULL);  if (g_str_has_prefix (header, "# GIMP Curves File/n"))    return gimp_curves_config_load_cruft (tool->config, input, error);  return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (image_map_tool,                                                                    input,                                                                    error);}

/* * et_ogg_tell_func: * @datasource: the Ogg parser state * * Tell the current position of the stream from the beginning of the Ogg file. * * Returns: the current position in the Ogg file */static longet_ogg_tell_func (void *datasource){    EtOggState *state = (EtOggState *)datasource;    return g_seekable_tell (G_SEEKABLE (state->istream));}

static gbooleangst_gio_base_sink_event (GstBaseSink * base_sink, GstEvent * event){  GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);  GstFlowReturn ret = GST_FLOW_OK;  if (sink->stream == NULL)    return TRUE;  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_SEGMENT:      if (G_IS_OUTPUT_STREAM (sink->stream)) {        const GstSegment *segment;        gst_event_parse_segment (event, &segment);        if (segment->format != GST_FORMAT_BYTES) {          GST_WARNING_OBJECT (sink, "ignored SEGMENT event in %s format",              gst_format_get_name (segment->format));          break;        }        if (GST_GIO_STREAM_IS_SEEKABLE (sink->stream)) {          ret = gst_gio_seek (sink, G_SEEKABLE (sink->stream), segment->start,              sink->cancel);          if (ret == GST_FLOW_OK)            sink->position = segment->start;        } else {          ret = GST_FLOW_NOT_SUPPORTED;        }      }      break;    case GST_EVENT_EOS:    case GST_EVENT_FLUSH_START:      if (G_IS_OUTPUT_STREAM (sink->stream)) {        gboolean success;        GError *err = NULL;        success = g_output_stream_flush (sink->stream, sink->cancel, &err);        if (!success && !gst_gio_error (sink, "g_output_stream_flush", &err,                &ret)) {          GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),              ("flush failed: %s", err->message));          g_clear_error (&err);        }      }      break;    default:      break;  }  if (ret == GST_FLOW_OK)    return GST_BASE_SINK_CLASS (parent_class)->event (base_sink, event);  else {    gst_event_unref (event);    return FALSE;  }}

static void on_file_read_ready (GObject * object, GAsyncResult * res, gpointer data){	GError *error = NULL;	GDownloadable *download = G_DOWNLOADABLE (data);	GioDownload   *gio_download = GIO_DOWNLOAD (data);	g_assert (download != NULL);		gio_download->priv->input = g_file_read_finish (G_FILE(object), res, &error); 	handle_critical_error (error);		if (gio_download->priv->input == NULL) {		// TODO: Error details		g_downloadable_set_status (download, G_DOWNLOADABLE_NETWORK_ERROR);	} else {		if (g_seekable_can_seek(G_SEEKABLE(gio_download->priv->input))			&& g_file_query_exists (download->priv->local_file, NULL)) {			//g_message ("appeding file .../n");			g_file_append_to_async (download->priv->local_file, 0,G_PRIORITY_DEFAULT,									NULL, on_file_append_to_ready, download); 		} else {			//g_message ("replacing file .../n");			g_file_replace_async (download->priv->local_file, NULL, FALSE, 0, G_PRIORITY_DEFAULT,								  NULL, on_file_replace_ready,  download);		}		g_downloadable_set_status (download, G_DOWNLOADABLE_DOWNLOADING);	}}

static gbooleangst_gio_base_src_start (GstBaseSrc * base_src){  GstGioBaseSrc *src = GST_GIO_BASE_SRC (base_src);  GstGioBaseSrcClass *gbsrc_class = GST_GIO_BASE_SRC_GET_CLASS (src);  src->position = 0;  /* FIXME: This will likely block */  src->stream = gbsrc_class->get_stream (src);  if (G_UNLIKELY (!G_IS_INPUT_STREAM (src->stream))) {    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),        ("No input stream provided by subclass"));    return FALSE;  } else if (G_UNLIKELY (g_input_stream_is_closed (src->stream))) {    GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (NULL),        ("Input stream is already closed"));    return FALSE;  }  if (G_IS_SEEKABLE (src->stream))    src->position = g_seekable_tell (G_SEEKABLE (src->stream));  GST_DEBUG_OBJECT (src, "started source");  return TRUE;}

static unsigned longvfs_stream_read (FT_Stream stream,		 unsigned long offset,		 unsigned char *buffer,		 unsigned long count){    GFileInputStream *handle = stream->descriptor.pointer;    gssize bytes_read = 0;    if (!count && offset > stream->size)        return 1;    if (!g_seekable_seek (G_SEEKABLE (handle), offset, G_SEEK_SET, NULL, NULL))        return (count ? 0 : 1);    if (count > 0) {        bytes_read = g_input_stream_read (G_INPUT_STREAM (handle), buffer,					  count, NULL, NULL);        if (bytes_read == -1)            return 0;    }    return bytes_read;}

/** * seahorse_util_memory_output_length: * @output: a stream * * A replacement for #g_memory_output_stream_get_data_size (since 2.18) * * Returns: The length of the stream */gsizeseahorse_util_memory_output_length (GMemoryOutputStream *output){	GSeekable *seekable;	goffset offset, end;		/* 	 * This is a replacement for g_memory_output_stream_get_data_size()	 * which is not available in current version of glib.	 */		g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (output), 0);	g_return_val_if_fail (G_IS_SEEKABLE (output), 0);		seekable = G_SEEKABLE (output);	offset = g_seekable_tell (seekable);		if (!g_seekable_seek (seekable, 0, G_SEEK_END, NULL, NULL))		g_return_val_if_reached (0);		end = g_seekable_tell (seekable);		if (offset != end) {		if (!g_seekable_seek (seekable, offset, G_SEEK_SET, NULL, NULL))			g_return_val_if_reached (0);	}		return (gsize)end;}

static gbooleang_resource_file_input_stream_can_seek (GFileInputStream *stream){  GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);  return G_IS_SEEKABLE (file->stream) && g_seekable_can_seek (G_SEEKABLE (file->stream));}

static gbooleancan_seek (GInputStream *stream){    if (!G_IS_SEEKABLE (stream))        return FALSE;    return g_seekable_can_seek (G_SEEKABLE (stream));}

gint main (gint argc, gchar **argv){	struct dirent *dent;	DIR *dir;	gint fd;	camel_test_init (argc, argv);	camel_test_start ("Message Test Suite");	if (!(dir = opendir ("../data/messages")))		return 77;	while ((dent = readdir (dir)) != NULL) {		CamelMimeMessage *message;		CamelStream *stream;		gchar *filename;		struct stat st;		if (dent->d_name[0] == '.')			continue;		filename = g_strdup_printf ("../data/messages/%s", dent->d_name);		if (g_stat (filename, &st) == -1 || !S_ISREG (st.st_mode)) {			g_free (filename);			continue;		}		if ((fd = open (filename, O_RDONLY)) == -1) {			g_free (filename);			continue;		}		push ("testing message '%s'", filename);		g_free (filename);		stream = camel_stream_fs_new_with_fd (fd);		message = camel_mime_message_new ();		camel_data_wrapper_construct_from_stream_sync (			CAMEL_DATA_WRAPPER (message), stream, NULL, NULL);		g_seekable_seek (			G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, NULL);		/*dump_mime_struct ((CamelMimePart *) message, 0);*/		test_message_compare (message);		g_object_unref (message);		g_object_unref (stream);		pull ();	}	closedir (dir);	camel_test_end ();	return 0;}

static gbooleanprocess(GeglOperation *operation,        GeglBuffer *input,        const GeglRectangle *result,        int level){  GeglProperties *o = GEGL_PROPERTIES(operation);  Priv *p = g_new0(Priv, 1);  gboolean status = TRUE;  GError *error = NULL;  g_assert(p != NULL);  o->user_data = (void*) p;  p->stream = gegl_gio_open_output_stream(NULL, o->path, &p->file, &error);  if (p->stream != NULL && p->file != NULL)    p->can_seek = g_seekable_can_seek(G_SEEKABLE(p->stream));  if (p->stream == NULL)    {      status = FALSE;      g_warning("%s", error->message);      goto cleanup;    }  TIFFSetErrorHandler(error_handler);  TIFFSetWarningHandler(warning_handler);  p->tiff = TIFFClientOpen("GEGL-tiff-save", "w", (thandle_t) p,                           read_from_stream, write_to_stream,                           seek_in_stream, close_stream,                           get_file_size, NULL, NULL);  if (p->tiff == NULL)    {      status = FALSE;      g_warning("failed to open TIFF from %s", o->path);      goto cleanup;    }  if (export_tiff(operation, input, result))    {      status = FALSE;      g_warning("could not export TIFF file");      goto cleanup;    }cleanup:  cleanup(operation);  if (o->user_data != NULL)    g_free(o->user_data);  o->user_data = NULL;  if (error != NULL)    g_error_free(error);  return status;}

static goffsetg_resource_file_input_stream_tell (GFileInputStream *stream){  GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);;  if (!G_IS_SEEKABLE (file->stream));      return 0;  return g_seekable_tell (G_SEEKABLE (file->stream));}

static int64_tddb_gvfs_tell (DB_FILE *stream){  vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;  g_return_val_if_fail (data != NULL, -1);  g_return_val_if_fail (! g_input_stream_is_closed (data->handle), -1);  return g_seekable_tell (G_SEEKABLE (data->handle));}

static guint64 get_code( GbdEmitter* _self,gchar* key ) {	GbdX11emitter* const self = GBD_X11EMITTER( _self );	GbdX11emitterPrivate* const priv = self->priv;	if( !priv->srcdata ) {		GFile* file = g_file_new_for_path( GBD_X11EMITTER_SRC );		if( !load_file( self,file,NULL ) ) {			g_critical( "GBoard X11-Emitter could not parse X11 keysymdef.h at " GBD_X11EMITTER_SRC );			return 0;		}		g_object_unref( file );	}	guint64* code,symval = 0;	if( ( code = g_datalist_get_data( &priv->mapcache,key ) ) )		return *code;	else		code = g_malloc( sizeof( guint64 ) );	g_seekable_seek( G_SEEKABLE( priv->srcstream ),0,G_SEEK_SET,NULL,NULL );	GDataInputStream* dis = priv->srcdata;	gchar* line;	gsize len = strlen( key );	gchar* keytoken = g_malloc( sizeof( gchar )*len+sizeof( KEYDEF_PREFIX )+1 );	sprintf( keytoken,KEYDEF_PREFIX "%s",key );	len = strlen( keytoken );	GError* err = NULL;	while( line = g_data_input_stream_read_line( dis,NULL,NULL,&err ) ) {		if( !strncmp( keytoken,line,len )&& g_ascii_isspace( line[ len ] ) ) {			if( sscanf( line+len," %" G_GINT64_MODIFIER "x ",&symval ) ) {				g_free( line );				break;			}		}		g_free( line );	}	if( err ) {		g_error( "%s",err->message );		g_error_unref( &err );	}	if( symval ) {		guint64 codeval = XKeysymToKeycode( priv->dpy,symval );		*code = codeval;		g_datalist_set_data_full( &priv->mapcache,key,code,g_free );		if( !codeval )			g_warning( "Could not find code for key '%s', Keysym-Value " G_GINT64_FORMAT,key,symval );		return codeval;	}	return 0;}

static gbooleangsf_input_gio_seek (GsfInput *input, gsf_off_t offset, GSeekType whence){    GsfInputGio *gio = GSF_INPUT_GIO (input);    g_return_val_if_fail (gio != NULL, TRUE);    g_return_val_if_fail (gio->stream != NULL, TRUE);    g_return_val_if_fail (can_seek (gio->stream), TRUE);    return (g_seekable_seek (G_SEEKABLE (gio->stream), offset, whence, NULL, NULL) ? FALSE : TRUE);}

    arrow::Status Tell(int64_t *position) const override {      if (!G_IS_SEEKABLE(output_stream_)) {        std::string message("[gio-output-stream][tell] "                            "not seekable output stream: <");        message += G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(output_stream_));        message += ">";        return arrow::Status::NotImplemented(message);      }      *position = g_seekable_tell(G_SEEKABLE(output_stream_));      return arrow::Status::OK();    }

/* * et_ogg_seek_func: * @datasource: the Ogg parser state * @offset: the number of bytes to seek * @whence: either %SEEK_SET, %SEEK_CUR or %SEEK_END * * Seek in the currently-open Ogg file. * * Returns: 0 on success, -1 and sets errno on error */static intet_ogg_seek_func (void *datasource, ogg_int64_t offset, int whence){    EtOggState *state = (EtOggState *)datasource;    GSeekType seektype;    if (!g_seekable_can_seek (G_SEEKABLE (state->istream)))    {        return -1;    }    else    {        switch (whence)        {            case SEEK_SET:                seektype = G_SEEK_SET;                break;            case SEEK_CUR:                seektype = G_SEEK_CUR;                break;            case SEEK_END:                seektype = G_SEEK_END;                break;            default:                errno = EINVAL;                return -1;        }        if (g_seekable_seek (G_SEEKABLE (state->istream), offset, seektype,                             NULL, &state->error))        {            return 0;        }        else        {            errno = EBADF;            return -1;        }    }}

static inline voidgegl_tile_backend_file_file_entry_read (GeglTileBackendFile *self,                                        GeglBufferTile      *entry,                                        guchar              *dest){  gint     to_be_read;  gboolean success;  gint     tile_size = gegl_tile_backend_get_tile_size (GEGL_TILE_BACKEND (self));  goffset  offset = entry->offset;  gegl_tile_backend_file_ensure_exist (self);#if HAVE_GIO  success = g_seekable_seek (G_SEEKABLE (self->i),                             offset, G_SEEK_SET,                             NULL, NULL);#else  success = (lseek (self->i, offset, SEEK_SET) >= 0);#endif  if (success == FALSE)    {      g_warning ("unable to seek to tile in buffer: %s", g_strerror (errno));      return;    }  to_be_read = tile_size;  while (to_be_read > 0)    {      gint byte_read;#if HAVE_GIO      byte_read = g_input_stream_read (G_INPUT_STREAM (self->i),                                       dest + tile_size - to_be_read, to_be_read,                                       NULL, NULL);#else      byte_read = read (self->i, dest + tile_size - to_be_read, to_be_read);#endif      if (byte_read <= 0)        {          g_message ("unable to read tile data from self: "                     "%s (%d/%d bytes read)",                     g_strerror (errno), byte_read, to_be_read);          return;        }      to_be_read -= byte_read;    }  GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "read entry %i,%i,%i at %i", entry->x, entry->y, entry->z, (gint)offset);}

static intddb_gvfs_seek (DB_FILE *stream, int64_t offset, int whence){  vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;  g_return_val_if_fail (data != NULL, -1);  if (!g_seekable_can_seek (G_SEEKABLE (data->handle)))    return -1;  g_return_val_if_fail (! g_input_stream_is_closed (data->handle), -1);  GSeekType seektype;  switch (whence) {    case SEEK_CUR:      seektype = G_SEEK_CUR;      break;    case SEEK_END:      seektype = G_SEEK_END;      break;    default:      seektype = G_SEEK_SET;      break;  }  GError *error = NULL;  if (g_seekable_seek (G_SEEKABLE (data->handle), offset, seektype, NULL, &error))    return 0;  g_warning ("Could not seek: %s", error->message);  g_error_free (error);  return -1;}

static inline voidgegl_tile_backend_file_file_entry_write (GeglTileBackendFile *self,                                         GeglBufferTile      *entry,                                         guchar              *source){  gint     to_be_written;  gboolean success;  gint     tile_size = gegl_tile_backend_get_tile_size (GEGL_TILE_BACKEND (self));  goffset  offset = entry->offset;  gegl_tile_backend_file_ensure_exist (self);#if HAVE_GIO  success = g_seekable_seek (G_SEEKABLE (self->o),                             offset, G_SEEK_SET,                             NULL, NULL);#else  success = (lseek (self->o, offset, SEEK_SET) >= 0);#endif  if (success == FALSE)    {      g_warning ("unable to seek to tile in buffer: %s", g_strerror (errno));      return;    }  to_be_written = tile_size;  while (to_be_written > 0)    {      gint wrote;#if HAVE_GIO      wrote = g_output_stream_write (self->o,                                     source + tile_size - to_be_written,                                     to_be_written, NULL, NULL);#else      wrote = write (self->o,                     source + tile_size - to_be_written,                     to_be_written);#endif      if (wrote <= 0)        {          g_message ("unable to write tile data to self: "                     "%s (%d/%d bytes written)",                     g_strerror (errno), wrote, to_be_written);          return;        }      to_be_written -= wrote;    }  GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "wrote entry %i,%i,%i at %i", entry->x, entry->y, entry->z, (gint)offset);}