Fix up includes in section docs
[platform/upstream/glib.git] / gio / gvfs.c
1 /* GIO - GLib Input, Output and Streaming Library
2  * 
3  * Copyright (C) 2006-2007 Red Hat, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General
16  * Public License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  * Author: Alexander Larsson <alexl@redhat.com>
21  */
22
23 #include <config.h>
24 #include <string.h>
25 #include "gvfs.h"
26 #include "glocalvfs.h"
27 #include "giomodule-priv.h"
28 #include "glibintl.h"
29
30 #include "gioalias.h"
31
32 /**
33  * SECTION:gvfs
34  * @short_description: Virtual File System 
35  * @include: gio.h
36  * 
37  * Entry point for using GIO functionality.
38  *
39  **/
40
41 G_DEFINE_TYPE (GVfs, g_vfs, G_TYPE_OBJECT);
42
43 static void
44 g_vfs_class_init (GVfsClass *klass)
45 {
46 }
47
48 static void
49 g_vfs_init (GVfs *vfs)
50 {
51 }
52
53 /**
54  * g_vfs_is_active:
55  * @vfs: a #GVfs.
56  * 
57  * Checks if the VFS is active.
58  * 
59  * Returns: %TRUE if construction of the @vfs was successful and it is now active.
60  **/
61 gboolean
62 g_vfs_is_active (GVfs *vfs)
63 {
64   GVfsClass *class;
65
66   g_return_val_if_fail (G_IS_VFS (vfs), FALSE);
67
68   class = G_VFS_GET_CLASS (vfs);
69
70   return (* class->is_active) (vfs);
71 }
72
73
74 /**
75  * g_vfs_get_file_for_path:
76  * @vfs: a #GVfs.
77  * @path: a string containing a VFS path.
78  * 
79  * Gets a #GFile for @path.
80  * 
81  * Returns: a #GFile.
82  **/
83 GFile *
84 g_vfs_get_file_for_path (GVfs       *vfs,
85                          const char *path)
86 {
87   GVfsClass *class;
88   
89   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
90   g_return_val_if_fail (path != NULL, NULL);
91
92   class = G_VFS_GET_CLASS (vfs);
93
94   return (* class->get_file_for_path) (vfs, path);
95 }
96
97 /**
98  * g_vfs_get_file_for_uri:
99  * @vfs: a#GVfs.
100  * @uri: a string containing a URI path.
101  * 
102  * Gets a #GFile for @uri.
103  * 
104  * This operation never fails, but the returned object
105  * might not support any I/O operation if the uri
106  * is malformed or if the uri type is not supported.
107  * 
108  * Returns: a #GFile. 
109  * 
110  **/
111 GFile *
112 g_vfs_get_file_for_uri (GVfs       *vfs,
113                         const char *uri)
114 {
115   GVfsClass *class;
116   
117   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
118   g_return_val_if_fail (uri != NULL, NULL);
119
120   class = G_VFS_GET_CLASS (vfs);
121
122   return (* class->get_file_for_uri) (vfs, uri);
123 }
124
125 /**
126  * g_vfs_get_supported_uri_schemes:
127  * @vfs: a #GVfs.
128  * 
129  * Gets a list of URI schemes supported by @vfs.
130  * 
131  * Returns: a list of strings.
132  **/
133 const gchar * const *
134 g_vfs_get_supported_uri_schemes (GVfs *vfs)
135 {
136   GVfsClass *class;
137   
138   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
139
140   class = G_VFS_GET_CLASS (vfs);
141
142   return (* class->get_supported_uri_schemes) (vfs);
143 }
144
145 /**
146  * g_vfs_parse_name:
147  * @vfs: a #GVfs.
148  * @parse_name: a string to be parsed by the VFS module.
149  * 
150  * This operation never fails, but the returned object might 
151  * not support any I/O operations if the @parse_name cannot 
152  * be parsed by the #GVfs module.
153  * 
154  * Returns: a #GFile for the given @parse_name.
155  **/
156 GFile *
157 g_vfs_parse_name (GVfs       *vfs,
158                   const char *parse_name)
159 {
160   GVfsClass *class;
161   
162   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
163   g_return_val_if_fail (parse_name != NULL, NULL);
164
165   class = G_VFS_GET_CLASS (vfs);
166
167   return (* class->parse_name) (vfs, parse_name);
168 }
169
170 /* Note: This compares in reverse order.
171    Higher prio -> sort first
172  */
173 static gint
174 compare_vfs_type (gconstpointer  a,
175                   gconstpointer  b,
176                   gpointer       user_data)
177 {
178   GVfsClass *class_a, *class_b;
179   gint res;
180   const char *use_this_vfs;
181   
182   class_a = g_type_class_ref (*(GType *)a);
183   class_b = g_type_class_ref (*(GType *)b);
184   use_this_vfs = user_data;
185
186   if (class_a == class_b)
187     res = 0;
188   else if (use_this_vfs != NULL &&
189            strcmp (class_a->name, use_this_vfs) == 0)
190     res = -1;
191   else if (use_this_vfs != NULL &&
192            strcmp (class_b->name, use_this_vfs) == 0)
193     res = 1;
194   else 
195     res = class_b->priority - class_a->priority;
196   
197   g_type_class_unref (class_a);
198   g_type_class_unref (class_b);
199   
200   return res;
201 }
202
203
204 static gpointer
205 get_default_vfs (gpointer arg)
206 {
207   volatile GType local_type;
208   GType *vfs_impls;
209   int i;
210   guint n_vfs_impls;
211   const char *use_this;
212   GVfs *vfs;
213   GType (*casted_get_type)(void);
214
215   use_this = g_getenv ("GIO_USE_VFS");
216   
217   /* Ensure GLocalVfs type is available
218      the cast is required to avoid any G_GNUC_CONST optimizations */
219   casted_get_type = _g_local_vfs_get_type;
220   local_type = casted_get_type ();
221   
222   /* Ensure vfs in modules loaded */
223   _g_io_modules_ensure_loaded ();
224
225   vfs_impls = g_type_children (G_TYPE_VFS, &n_vfs_impls);
226
227   g_qsort_with_data (vfs_impls, n_vfs_impls, sizeof (GType),
228                      compare_vfs_type, (gpointer)use_this);
229   
230   for (i = 0; i < n_vfs_impls; i++)
231     {
232       vfs = g_object_new (vfs_impls[i], NULL);
233
234       if (g_vfs_is_active (vfs))
235         break;
236
237       g_object_unref (vfs);
238       vfs = NULL;
239     }
240   
241   g_free (vfs_impls);
242
243   return vfs;
244 }
245
246 /**
247  * g_vfs_get_default:
248  * 
249  * Gets the default #GVfs for the system.
250  * 
251  * Returns: a #GVfs. 
252  **/
253 GVfs *
254 g_vfs_get_default (void)
255 {
256   static GOnce once_init = G_ONCE_INIT;
257   
258   return g_once (&once_init, get_default_vfs, NULL);
259 }
260
261 /**
262  * g_vfs_get_local:
263  * 
264  * Gets the local #GVfs for the system.
265  * 
266  * Returns: a #GVfs.
267  **/
268 GVfs *
269 g_vfs_get_local (void)
270 {
271   static gsize vfs = 0;
272
273   if (g_once_init_enter (&vfs))
274     g_once_init_leave (&vfs, (gsize)_g_local_vfs_new ());
275
276   return G_VFS (vfs);
277 }
278
279 #define __G_VFS_C__
280 #include "gioaliasdef.c"