IDL Definitions

07 April 2004

# Appendix A: IDL Definitions

This appendix contains the complete OMG IDL [OMG IDL] for the Level 3 Document Object Model Abstract Schemas and Load and Save definitions.

The IDL files are also available as: http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/idl.zip

### ls.idl:

    // File: ls.idl

    #ifndef _LS_IDL_
    #define _LS_IDL_

    #include "dom.idl"
    #include "events.idl"
    #include "traversal.idl"

    #pragma prefix "dom.w3c.org"
    module ls
    {

      typedef   Object LSInputStream;

      typedef   Object LSOutputStream;

      typedef   Object LSReader;

      typedef   Object LSWriter;

      typedef dom::DOMString DOMString;
      typedef dom::DOMConfiguration DOMConfiguration;
      typedef dom::Node Node;
      typedef dom::Document Document;
      typedef dom::Element Element;

      interface LSParser;
      interface LSSerializer;
      interface LSInput;
      interface LSOutput;
      interface LSParserFilter;
      interface LSSerializerFilter;

      exception LSException {
        unsigned short   code;
      };
      // LSExceptionCode
      const unsigned short      PARSE_ERR                      = 81;
      const unsigned short      SERIALIZE_ERR                  = 82;

      interface DOMImplementationLS {

        // DOMImplementationLSMode
        const unsigned short      MODE_SYNCHRONOUS               = 1;
        const unsigned short      MODE_ASYNCHRONOUS              = 2;

        LSParser           createLSParser(in unsigned short mode,
                                          in DOMString schemaType)
                                            raises(dom::DOMException);
        LSSerializer       createLSSerializer();
        LSInput            createLSInput();
        LSOutput           createLSOutput();
      };

      interface LSParser {
        readonly attribute DOMConfiguration domConfig;
                 attribute LSParserFilter  filter;
        readonly attribute boolean         async;
        readonly attribute boolean         busy;
        Document           parse(in LSInput input)
                                            raises(dom::DOMException,
                                                   LSException);
        Document           parseURI(in DOMString uri)
                                            raises(dom::DOMException,
                                                   LSException);

        // ACTION_TYPES
        const unsigned short      ACTION_APPEND_AS_CHILDREN      = 1;
        const unsigned short      ACTION_REPLACE_CHILDREN        = 2;
        const unsigned short      ACTION_INSERT_BEFORE           = 3;
        const unsigned short      ACTION_INSERT_AFTER            = 4;
        const unsigned short      ACTION_REPLACE                 = 5;

        Node               parseWithContext(in LSInput input,
                                            in Node contextArg,
                                            in unsigned short action)
                                            raises(dom::DOMException,
                                                   LSException);
        void               abort();
      };

      interface LSInput {
        // Depending on the language binding in use,
        // this attribute may not be available.
                 attribute LSReader        characterStream;
                 attribute LSInputStream   byteStream;
                 attribute DOMString       stringData;
                 attribute DOMString       systemId;
                 attribute DOMString       publicId;
                 attribute DOMString       baseURI;
                 attribute DOMString       encoding;
                 attribute boolean         certifiedText;
      };

      interface LSResourceResolver {
        LSInput            resolveResource(in DOMString type,
                                           in DOMString namespaceURI,
                                           in DOMString publicId,
                                           in DOMString systemId,
                                           in DOMString baseURI);
      };

      interface LSParserFilter {

        // Constants returned by startElement and acceptNode
        const short               FILTER_ACCEPT                  = 1;
        const short               FILTER_REJECT                  = 2;
        const short               FILTER_SKIP                    = 3;
        const short               FILTER_INTERRUPT               = 4;

        unsigned short     startElement(in Element elementArg);
        unsigned short     acceptNode(in Node nodeArg);
        readonly attribute unsigned long   whatToShow;
      };

      interface LSSerializer {
        readonly attribute DOMConfiguration domConfig;
                 attribute DOMString       newLine;
                 attribute LSSerializerFilter filter;
        boolean            write(in Node nodeArg,
                                 in LSOutput destination)
                                            raises(LSException);
        boolean            writeToURI(in Node nodeArg,
                                      in DOMString uri)
                                            raises(LSException);
        DOMString          writeToString(in Node nodeArg)
                                            raises(dom::DOMException,
                                                   LSException);
      };

      interface LSOutput {
        // Depending on the language binding in use,
        // this attribute may not be available.
                 attribute LSWriter        characterStream;
                 attribute LSOutputStream  byteStream;
                 attribute DOMString       systemId;
                 attribute DOMString       encoding;
      };

      interface LSProgressEvent : events::Event {
        readonly attribute LSInput         input;
        readonly attribute unsigned long   position;
        readonly attribute unsigned long   totalSize;
      };

      interface LSLoadEvent : events::Event {
        readonly attribute Document        newDocument;
        readonly attribute LSInput         input;
      };

      interface LSSerializerFilter : traversal::NodeFilter {
        readonly attribute unsigned long   whatToShow;
      };
    };

    #endif // _LS_IDL_