summaryrefslogtreecommitdiff
path: root/rdf/base/nsIRDFXMLSink.idl
blob: 8c9d9461c5f5b870bfa47dd5342d70207b9c140e (plain)
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
/* -*- 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/. */

/*

  Interfaces for the RDF/XML sink, which parses RDF/XML into
  a graph representation.

*/

#include "nsISupports.idl"

// XXX Until these get scriptable. See nsIRDFXMLSink::AddNameSpace()
[ptr] native nsIAtomPtr(nsIAtom);
[ref] native nsStringRef(nsString);
%{C++
class nsIAtom;
class nsString;
%}

interface nsIRDFXMLSink;

/**
 * An observer that is notified as progress is made on the load
 * of an RDF/XML document in an <code>nsIRDFXMLSink</code>.
 */
[scriptable, uuid(EB1A5D30-AB33-11D2-8EC6-00805F29F370)]
interface nsIRDFXMLSinkObserver : nsISupports
{
    /**
     * Called when the load begins.
     * @param aSink the RDF/XML sink on which the load is beginning.
     */
    void onBeginLoad(in nsIRDFXMLSink aSink);

    /**
     * Called when the load is suspended (e.g., for network quantization).
     * @param aSink the RDF/XML sink that is being interrupted.
     */
    void onInterrupt(in nsIRDFXMLSink aSink);

    /**
     * Called when a suspended load is resuming.
     * @param aSink the RDF/XML sink that is resuming.
     */
    void onResume(in nsIRDFXMLSink aSink);

    /**
     * Called when an RDF/XML load completes successfully.
     * @param aSink the RDF/XML sink that has finished loading.
     */
    void onEndLoad(in nsIRDFXMLSink aSink);

    /**
     * Called when an error occurs during the load
     * @param aSink the RDF/XML sink in which the error occurred
     * @param aStatus the networking result code
     * @param aErrorMsg an error message, if applicable
     */
    void onError(in nsIRDFXMLSink aSink, in nsresult aStatus, in wstring aErrorMsg);
};



/**
 * A "sink" that receives and processes RDF/XML. This interface is used
 * by the RDF/XML parser.
 */
[scriptable, uuid(EB1A5D31-AB33-11D2-8EC6-00805F29F370)]
interface nsIRDFXMLSink : nsISupports
{
    /**
     * Set to <code>true</code> if the sink is read-only and cannot
     * be modified
     */
    attribute boolean readOnly;

    /**
     * Initiate the RDF/XML load.
     */
    void beginLoad();

    /**
     * Suspend the RDF/XML load.
     */
    void interrupt();

    /**
     * Resume the RDF/XML load.
     */
    void resume();

    /**
     * Complete the RDF/XML load.
     */
    void endLoad();

    /**
     * Add namespace information to the RDF/XML sink.
     * @param aPrefix the namespace prefix
     * @param aURI the namespace URI
     */
    [noscript] void addNameSpace(in nsIAtomPtr aPrefix,
                                 [const] in nsStringRef aURI);

    /**
     * Add an observer that will be notified as the RDF/XML load
     * progresses.
     * <p>
     *
     * Note that the sink will acquire a strong reference to the
     * observer, so care should be taken to avoid cyclical references
     * that cannot be released (i.e., if the observer holds a
     * reference to the sink, it should be sure that it eventually
     * clears the reference).
     *
     * @param aObserver the observer to add to the sink's set of
     * load observers.
     */
    void addXMLSinkObserver(in nsIRDFXMLSinkObserver aObserver);

    /**
     * Remove an observer from the sink's set of observers.
     * @param aObserver the observer to remove.
     */
    void removeXMLSinkObserver(in nsIRDFXMLSinkObserver aObserver);
};