← Back to branch summary

~ubuntu-branches/ubuntu/breezy/redland-bindings/breezy

« back to all changes in this revision

Viewing changes to csharp/Serializer.cs

  • Committer: Bazaar Package Importer
  • Author(s): Fabio M. Di Nitto
  • Date: 2005-06-21 12:56:49 UTC
  • mfrom: (1.1.1 upstream) (0.1.2 sarge)
  • Revision ID: james.westby@ubuntu.com-20050621125649-1uwxez1hdyzw6vzd
Tags: 1.0.2.1-1ubuntu1
* Resynchronise with Debian.

* Fix FTBFS: Add python2.4-dev Build-Dep.

Show diffs side-by-side

added added

removed removed

Lines of Context:
csharp/Serializer.cs
1
1
//
2
2
// Serializer.cs: Redland Serialize to syntax class
3
3
//
4
 
// $Id: Serializer.cs,v 1.8 2004/07/14 16:17:13 cmdjb Exp $
 
4
// $Id: Serializer.cs,v 1.10 2005/01/05 11:41:42 edd Exp $
5
5
//
6
6
// Author:
7
7
//      Cesar Lopez Nataren (cesar@ciencias.unam.mx)
16
16
 
17
17
        public class Serializer : IWrapper, IDisposable {
18
18
 
19
 
                IntPtr serializer = IntPtr.Zero;
20
 
 
21
 
                bool disposed = false;
22
 
 
23
 
                public IntPtr Handle {
24
 
                        get { return serializer; }
 
19
                private HandleRef handle;
 
20
 
 
21
                private bool disposed = false;
 
22
                private World world = Redland.World.AddReference ();
 
23
 
 
24
                public HandleRef Handle {
 
25
                        get { return handle; }
25
26
                }
26
27
 
 
28
                [DllImport ("librdf")]
 
29
                static extern IntPtr librdf_new_serializer (HandleRef world, IntPtr name, IntPtr mime_type, IntPtr type_uri);
 
30
 
27
31
                public Serializer (string name, string mime_type, Uri type_uri)
28
 
                        : this (Redland.World, name, mime_type, type_uri)
29
 
                {
30
 
                }
31
 
 
32
 
                [DllImport ("librdf")]
33
 
                static extern IntPtr librdf_new_serializer (IntPtr world, IntPtr name, IntPtr mime_type, IntPtr type_uri);
34
 
 
35
 
                private Serializer (World world, string name, string mime_type, Uri type_uri)
36
 
                {
37
 
                        IntPtr iname = Marshal.StringToHGlobalAuto (name);
38
 
                        IntPtr imime_type = Marshal.StringToHGlobalAuto (mime_type);
39
 
                        if (world == null)
40
 
                                if (type_uri == null)
41
 
                                        serializer = librdf_new_serializer (IntPtr.Zero, iname, imime_type, IntPtr.Zero);
42
 
                                else
43
 
                                        serializer = librdf_new_serializer (IntPtr.Zero, iname, imime_type, type_uri.Handle);
44
 
                        else if (type_uri == null)
45
 
                                serializer = librdf_new_serializer (world.Handle, iname, imime_type, IntPtr.Zero);
 
32
                {
 
33
                        IntPtr iname = Util.StringToHGlobalUTF8 (name);
 
34
                        IntPtr imime_type = Util.StringToHGlobalUTF8 (mime_type);
 
35
                        IntPtr serializer = IntPtr.Zero;
 
36
 
 
37
                        if (type_uri == null)
 
38
                                serializer = librdf_new_serializer 
 
39
                                        (world.Handle, iname, imime_type, IntPtr.Zero);
46
40
                        else
47
 
                                serializer = librdf_new_serializer (world.Handle, iname, imime_type, type_uri.Handle);
48
 
                        Marshal.FreeHGlobal (iname);
49
 
                        Marshal.FreeHGlobal (imime_type);
 
41
                                serializer = librdf_new_serializer
 
42
                                        (world.Handle, iname, imime_type, type_uri.Handle.Handle);
50
43
 
 
44
                        handle = new HandleRef (this, serializer);
 
45
                        Marshal.FreeHGlobal (iname);
 
46
                        Marshal.FreeHGlobal (imime_type);
51
47
                }
52
48
 
53
49
                [DllImport ("librdf")]
54
 
                static extern void librdf_free_serializer (IntPtr serializer);
 
50
                static extern void librdf_free_serializer (HandleRef serializer);
55
51
 
56
52
                protected void Dispose (bool disposing)
57
53
                {
59
55
                                // if disposing is true, then dispose of managed
60
56
                                // resources
61
57
 
62
 
                                if (serializer != IntPtr.Zero) {
63
 
                                        librdf_free_serializer (serializer);
64
 
                                        serializer = IntPtr.Zero;
 
58
                                if (handle.Handle != IntPtr.Zero) {
 
59
                                        librdf_free_serializer (handle);
 
60
                                        handle = new HandleRef (this, IntPtr.Zero);
65
61
                                }
 
62
                                world.RemoveReference ();
 
63
                                world = null;
66
64
                                disposed = true;
67
65
                        }
68
66
                }
79
77
                }
80
78
 
81
79
                [DllImport ("librdf")]
82
 
                static extern int librdf_serializer_serialize_model (IntPtr serializer, IntPtr file, IntPtr base_uri, IntPtr model);
 
80
                static extern int librdf_serializer_serialize_model (HandleRef serializer, IntPtr file, HandleRef base_uri, HandleRef model);
83
81
 
84
82
                public int SerializeModel (IntPtr file, Uri base_uri, Model model)
85
83
                {
86
84
                        // FIXME: throw exceptions instead of using ret code?
87
 
                        return librdf_serializer_serialize_model (serializer, file, base_uri.Handle, model.Handle);
 
85
                        return librdf_serializer_serialize_model (handle, file, base_uri.Handle, model.Handle);
88
86
                }
89
87
 
90
88
 
91
89
                [DllImport ("librdf")]
92
 
                static extern int librdf_serializer_serialize_model_to_file (IntPtr serializer, IntPtr name, IntPtr base_uri, IntPtr model);
 
90
                static extern int librdf_serializer_serialize_model_to_file (HandleRef serializer, IntPtr name, HandleRef base_uri, HandleRef model);
93
91
 
94
92
                public int SerializeModel (string name, Uri base_uri, Model model)
95
93
                {
96
 
                        IntPtr iname = Marshal.StringToHGlobalAuto (name);
97
 
                        int ret = librdf_serializer_serialize_model_to_file (serializer, iname, base_uri.Handle, model.Handle);
 
94
                        IntPtr iname = Util.StringToHGlobalUTF8 (name);
 
95
                        int ret = librdf_serializer_serialize_model_to_file (handle, iname, base_uri.Handle, model.Handle);
98
96
                        Marshal.FreeHGlobal (iname);
99
97
                        // FIXME: throw exceptions instead of using ret code?
100
98
                        return ret;