1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "nsIRDFResource.idl"
#include "nsIRDFLiteral.idl"
#include "nsIRDFDataSource.idl"
/**
* The RDF service interface. This is a singleton object which should be
* obtained from the <code>nsServiceManager</code>.
*/
[scriptable, uuid(BFD05261-834C-11d2-8EAC-00805F29F370)]
interface nsIRDFService : nsISupports {
/**
* Construct an RDF resource from a single-byte URI. <code>nsIRDFService</code>
* caches resources that are in-use, so multiple calls to <code>GetResource()</code>
* for the same <code>uri</code> will return identical pointers. FindResource
* is used to find out whether there already exists a resource corresponding to that url.
*/
nsIRDFResource GetResource(in AUTF8String aURI);
/**
* Construct an RDF resource from a Unicode URI. This is provided
* as a convenience method, allowing automatic, in-line C++
* conversion from <code>nsString</code> objects. The <code>uri</code> will
* be converted to a single-byte representation internally.
*/
nsIRDFResource GetUnicodeResource(in AString aURI);
nsIRDFResource GetAnonymousResource();
/**
* Construct an RDF literal from a Unicode string.
*/
nsIRDFLiteral GetLiteral(in wstring aValue);
/**
* Construct an RDF literal from a PRTime.
*/
nsIRDFDate GetDateLiteral(in PRTime aValue);
/**
* Construct an RDF literal from an int.
*/
nsIRDFInt GetIntLiteral(in long aValue);
/**
* Construct an RDF literal from a data blob
*/
[noscript] nsIRDFBlob getBlobLiteral(in const_octet_ptr aValue, in long aLength);
boolean IsAnonymousResource(in nsIRDFResource aResource);
/**
* Registers a resource with the RDF system, making it unique w.r.t.
* GetResource.
*
* An implementation of nsIRDFResource should call this in its
* Init() method if it wishes the resource to be globally unique
* (which is usually the case).
*
* @note that the resource will <i>not</i> be ref-counted by the
* RDF service: the assumption is that the resource implementation
* will call nsIRDFService::UnregisterResource() when the last
* reference to the resource is released.
*
* @note that the nsIRDFService implementation may choose to
* maintain a reference to the resource's URI; therefore, the
* resource implementation should ensure that the resource's URI
* (accessible via nsIRDFResource::GetValue(const char* *aURI)) is
* valid before calling RegisterResource(). Furthermore, the
* resource implementation should ensure that this pointer
* <i>remains</i> valid for the lifetime of the resource. (The
* implementation of the resource cache in nsIRDFService uses the
* URI maintained "internally" in the resource as a key into the
* cache rather than copying the resource URI itself.)
*/
void RegisterResource(in nsIRDFResource aResource, in boolean aReplace);
/**
* Called to notify the resource manager that a resource is no
* longer in use. This method should only be called from the
* destructor of a "custom" resource implementation to notify the
* RDF service that the last reference to the resource has been
* released, so the resource is no longer valid.
*
* @note As mentioned in nsIRDFResourceFactory::CreateResource(),
* the RDF service will use the result of
* nsIRDFResource::GetValue() as a key into its cache. For this
* reason, you must always un-cache the resource <b>before</b>
* releasing the storage for the <code>const char*</code> URI.
*/
void UnregisterResource(in nsIRDFResource aResource);
/**
* Register a <i>named data source</i>. The RDF service will call
* <code>nsIRDFDataSource::GetURI()</code> to determine the URI under
* which to register the data source.
*
* @note that the data source will <i>not</i> be refcounted by the
* RDF service! The assumption is that an RDF data source
* registers with the service once it is initialized (via
* <code>nsIRDFDataSource::Init()</code>), and unregisters when the
* last reference to the data source is released.
*/
void RegisterDataSource(in nsIRDFDataSource aDataSource,
in boolean aReplace);
/**
* Unregister a <i>named data source</i>. The RDF service will call
* <code>nsIRDFDataSource::GetURI()</code> to determine the URI under which the
* data source was registered.
*/
void UnregisterDataSource(in nsIRDFDataSource aDataSource);
/**
* Get the <i>named data source</i> corresponding to the URI. If a data
* source has been registered via <code>RegisterDataSource()</code>, that
* data source will be returned.
*
* If no data source is currently
* registered for the specified URI, and a data source <i>constructor</i>
* function has been registered via <code>RegisterDatasourceConstructor()</code>,
* the RDF service will call the constructor to attempt to construct a
* new data source. If construction is successful, the data source will
* be initialized via <code>nsIRDFDataSource::Init()</code>.
*/
nsIRDFDataSource GetDataSource(in string aURI);
/**
* Same as GetDataSource, but if a remote/XML data source needs to be
* constructed, then this method will issue a <b>blocking</b> Refresh
* call on that data source.
*/
nsIRDFDataSource GetDataSourceBlocking(in string aURI);
};
%{C++
extern nsresult
NS_NewRDFService(nsIRDFService** result);
%}
|
