// Copyright (c) 1994 James Clark

// See the file COPYING for copying permission.

#ifndef Event_INCLUDED

#define Event_INCLUDED 1

#ifdef __GNUG__

#pragma interface

#endif

#include "Link.h"

#include "Allocator.h"

#include "Location.h"

#include "Vector.h"

#include "Owner.h"

#include "Boolean.h"

#include "types.h"

#include "Ptr.h"

#include "StringC.h"

#include "Notation.h"

#include "Sd.h"

#include "Syntax.h"

#include "Dtd.h"

#include "ElementType.h"

#include "Text.h"

#include "Lpd.h"

#include "Message.h"

#include "Markup.h"

#include "ShortReferenceMap.h"

#ifdef SP_NAMESPACE

namespace SP_NAMESPACE {

#endif

class EventHandler;

class SP_API Event : public Link {

public:

  enum Type {

    message,

    characterData,

    startElement,

    endElement,

    pi,

    sdataEntity,

    externalDataEntity,

    subdocEntity,

    nonSgmlChar,

    appinfo,

    startDtd,

    endDtd,

    startLpd,

    endLpd,

    endProlog,

    sgmlDecl,

    uselink,

    usemap,

    commentDecl,

    sSep,

    ignoredRs,

    ignoredRe,

    reOrigin,

    ignoredChars,

    markedSectionStart,

    markedSectionEnd,

    entityStart,

    entityEnd,

    notationDecl,

    entityDecl,

    elementDecl,

    attlistDecl,		// not #NOTATION and not in LPD

    attlistNotationDecl,

    linkAttlistDecl,

    linkDecl,

    idLinkDecl,

    shortrefDecl,

    ignoredMarkup,

    entityDefaulted,

    sgmlDeclEntity

    };

  Event(Type);

  virtual ~Event();

  virtual void handle(EventHandler &) = 0;

  virtual void copyData();

  void *operator new(size_t sz, Allocator &alloc) { return alloc.alloc(sz); }

  void *operator new(size_t sz) { return Allocator::allocSimple(sz); }

  void operator delete(void *p) { Allocator::free(p); }

#ifdef SP_HAVE_PLACEMENT_OPERATOR_DELETE

  void operator delete(void *p, Allocator &) { Allocator::free(p); }

#endif

  Type type() const;

private:

  Event(const Event &);		// undefined

  void operator=(const Event &); // undefined

  Type type_;

};

class LocatedEvent : public Event {

public:

  LocatedEvent(Type type, const Location &);

  const Location &location() const;

private:

  LocatedEvent(const LocatedEvent &); // undefined

  void operator=(const LocatedEvent &);	// undefined

  Location location_;

};

class MarkupEvent : public LocatedEvent {

public:

  MarkupEvent(Type type);

  MarkupEvent(Type type, const Location &, Markup *);

  const Markup &markup() const;

private:

  MarkupEvent(const MarkupEvent &); // undefined

  void operator=(const MarkupEvent &);	// undefined

  Markup markup_;

};

class SP_API MessageEvent : public Event {

public:

  MessageEvent(Message &);

  MessageEvent(const Message &);

  ~MessageEvent();

  const Message &message() const;

  void handle(EventHandler &);

private:

  MessageEvent(const MessageEvent &); // undefined

  void operator=(const MessageEvent &);	// undefined

  Message message_;

};

class AttributeList;

class StartElementEvent : public LocatedEvent {

public:

  StartElementEvent(const ElementType *,

		    const ConstPtr<Dtd> &,

		    AttributeList *,

		    const Location &,

		    Markup *);

  ~StartElementEvent();

  void handle(EventHandler &);

  Boolean mustOmitEnd() const;

  void setIncluded();

  Boolean included() const;

  const StringC &name() const;

  const ElementType *elementType() const;

  const Markup *markupPtr() const;

  const AttributeList &attributes() const;

  void copyData();

private:

  StartElementEvent(const StartElementEvent &);	// undefined

  void operator=(const StartElementEvent &);	// undefined

  const ElementType *elementType_;

  ConstPtr<Dtd> dtd_;

  PackedBoolean included_;

  PackedBoolean copied_;	// has copyData() been called

  Markup *markup_;

  AttributeList *attributes_;

};

class EndElementEvent : public LocatedEvent {

public:

  EndElementEvent(const ElementType *,

		  const ConstPtr<Dtd> &,

		  const Location &,

		  Markup *);

  ~EndElementEvent();

  void handle(EventHandler &);

  void setIncluded();

  Boolean included() const;

  const StringC &name() const;

  const ElementType *elementType() const;

  const Markup *markupPtr() const;

  void copyData();

private:

  EndElementEvent(const EndElementEvent &); // undefined

  void operator=(const EndElementEvent &);  // undefined

  const ElementType *elementType_;

  ConstPtr<Dtd> dtd_;

  PackedBoolean included_;

  PackedBoolean copied_;	// has copyData() been called

  Markup *markup_;

};

class DataEvent : public LocatedEvent {

public:

  DataEvent(Type, const Char *, size_t, const Location &);

  void handle(EventHandler &);

  const Char *data() const;

  size_t dataLength() const;

  virtual Boolean isRe(unsigned long &serial) const;

  virtual const Entity *entity() const;

protected:

  const Char *p_;

  size_t length_;

private:

  DataEvent(const DataEvent &);	// undefined

  void operator=(const DataEvent &); // undefined

};

class ImmediateDataEvent : public DataEvent {

public:

  ImmediateDataEvent(Type type, const Char *, size_t, const Location &,

		     Boolean copy);

  ~ImmediateDataEvent();

  void copyData();

private:

  ImmediateDataEvent(const ImmediateDataEvent &); // undefined

  void operator=(const ImmediateDataEvent &);	  // undefined

  Char *alloc_;

};

class InternalDataEntity;

class DataEntityEvent : public DataEvent {

public:

  DataEntityEvent(Type type, const InternalEntity *,

		  const ConstPtr<Origin> &);

  const Entity *entity() const;

private:

  DataEntityEvent(const DataEntityEvent &); // undefined

  void operator=(const DataEntityEvent &);  // undefined

};

class InternalCdataEntity;

class CdataEntityEvent : public DataEntityEvent {

public:

  CdataEntityEvent(const InternalEntity *,

		   const ConstPtr<Origin> &);

private:

  CdataEntityEvent(const CdataEntityEvent &); // undefined

  void operator=(const CdataEntityEvent &);   // undefined

};

class InternalSdataEntity;

class SdataEntityEvent : public DataEntityEvent {

public:

  SdataEntityEvent(const InternalEntity *,

		   const ConstPtr<Origin> &);

  void handle(EventHandler &);

private:

  SdataEntityEvent(const SdataEntityEvent &); // undefined

  void operator=(const SdataEntityEvent &);   // undefined

};

class PiEntity;

class PiEvent : public LocatedEvent {

public:

  PiEvent(const Char *, size_t, const Location &);

  const Char *data() const;

  size_t dataLength() const;

  virtual const Entity *entity() const;

  void handle(EventHandler &);

private:

  PiEvent(const PiEvent &);	// undefined

  void operator=(const PiEvent &); // undefined

  const Char *data_;

  size_t dataLength_;

};

class ImmediatePiEvent : public PiEvent {

public:

  ImmediatePiEvent(StringC &, const Location &);

private:

  ImmediatePiEvent(const ImmediatePiEvent &); // undefined

  void operator=(const ImmediatePiEvent &);   // undefined

  StringC string_;

};

class PiEntityEvent : public PiEvent {

public:

  PiEntityEvent(const PiEntity *entity,

		const ConstPtr<Origin> &origin);

  const Entity *entity() const;

private:

  PiEntityEvent(const PiEntityEvent &);	// undefined

  void operator=(const PiEntityEvent &); // undefined

};

class ExternalNonTextEntity;

class ExternalDataEntity;

class SubdocEntity;

class ExternalEntityEvent : public Event {

public:

  ExternalEntityEvent(Type type,

		      const ConstPtr<EntityOrigin> &);

  const ConstPtr<EntityOrigin> &entityOrigin() const;

  const Location &location() const;

private:

  ExternalEntityEvent(const ExternalEntityEvent &); // undefined

  void operator=(const ExternalEntityEvent &);	    // undefined

  ConstPtr<EntityOrigin> origin_;

};

class ExternalDataEntityEvent : public ExternalEntityEvent {

public:

  ExternalDataEntityEvent(const ExternalDataEntity *,

			  const ConstPtr<EntityOrigin> &);

  void handle(EventHandler &);

  const ExternalDataEntity *entity() const;

private:

  ExternalDataEntityEvent(const ExternalDataEntityEvent &); // undefined

  void operator=(const ExternalDataEntityEvent &);	    // undefined

  const ExternalDataEntity *dataEntity_;

};

class SubdocEntityEvent : public ExternalEntityEvent {

public:

  SubdocEntityEvent(const SubdocEntity *,

		    const ConstPtr<EntityOrigin> &);

  void handle(EventHandler &);

  const SubdocEntity *entity() const;

private:

  SubdocEntityEvent(const SubdocEntityEvent &);	// undefined

  void operator=(const SubdocEntityEvent &);	// undefined

  const SubdocEntity *subdocEntity_;

};

class NonSgmlCharEvent : public LocatedEvent {

public:

  NonSgmlCharEvent(Char c, const Location &);

  Char character() const;

  void handle(EventHandler &);

private:

  NonSgmlCharEvent(const NonSgmlCharEvent &); // undefined

  void operator=(const NonSgmlCharEvent &);   // undefined

  Char c_;

};

class AppinfoEvent : public LocatedEvent {

public:

  AppinfoEvent(const Location &);

  AppinfoEvent(const Text &, const Location &);

  void handle(EventHandler &);

  Boolean literal(const StringC *&) const;

private:

  AppinfoEvent(const AppinfoEvent &); // undefined

  void operator=(const AppinfoEvent &);	// undefined

  Boolean appinfoNone_;

  Text appinfo_;

};

class UselinkEvent : public MarkupEvent {

public:

  UselinkEvent(const ConstPtr<Lpd> &,

	       const LinkSet *,

	       Boolean restore,

	       const Location &,

	       Markup *);

  void handle(EventHandler &);

  const ConstPtr<Lpd> &lpd() const;

  const LinkSet *linkSet() const;

  Boolean restore() const;

private:

  UselinkEvent(const UselinkEvent &); // undefined

  void operator=(const UselinkEvent &);	// undefined

  ConstPtr<Lpd> lpd_;

  const LinkSet *linkSet_;

  Boolean restore_;

};

class UsemapEvent : public MarkupEvent {

public:

  UsemapEvent(const ShortReferenceMap *,

	      Vector<const ElementType *> &,

	      const ConstPtr<Dtd> &,

	      const Location &,

	      Markup *);

  void handle(EventHandler &);

  const ShortReferenceMap *map() const;

  const Vector<const ElementType *> &elements() const;

private:

  UsemapEvent(const UsemapEvent &); // undefined

  void operator=(const UsemapEvent &); // undefined

  ConstPtr<Dtd> dtd_;

  Vector<const ElementType *> elements_;

  const ShortReferenceMap *map_;

};

class StartSubsetEvent : public MarkupEvent {

public:

  StartSubsetEvent(Type,

		   const StringC &,

		   const ConstPtr<Entity> &entity,

		   Boolean hasInternalSubset,

		   const Location &,

		   Markup *);

  const StringC &name() const;

  const ConstPtr<Entity> &entity() const;

  Boolean hasInternalSubset() const;

private:

  StartSubsetEvent(const StartSubsetEvent &);	// undefined

  void operator=(const StartSubsetEvent &); // undefined

  StringC name_;

  ConstPtr<Entity> entity_;

  Boolean hasInternalSubset_;

};

class StartDtdEvent : public StartSubsetEvent {

public:

  StartDtdEvent(const StringC &,

		const ConstPtr<Entity> &entity,

		Boolean hasInternalSubset,

		const Location &,

		Markup *);

  void handle(EventHandler &);

private:

  StartDtdEvent(const StartDtdEvent &);	// undefined

  void operator=(const StartDtdEvent &); // undefined

};

class StartLpdEvent : public StartSubsetEvent {

public:

  StartLpdEvent(Boolean active,

		const StringC &,

		const ConstPtr<Entity> &entity,

		Boolean hasInternalSubset,

		const Location &,

		Markup *);

  void handle(EventHandler &);

  Boolean active() const;

private:

  StartLpdEvent(const StartLpdEvent &);	// undefined

  void operator=(const StartLpdEvent &); // undefined

  Boolean active_;

};

class EndDtdEvent : public MarkupEvent {

public:

  EndDtdEvent(const ConstPtr<Dtd> &, const Location &,

	      Markup *);

  void handle(EventHandler &);

  const Dtd &dtd() const;

  const ConstPtr<Dtd> &dtdPointer() const;

private:

  EndDtdEvent(const EndDtdEvent &); // undefined

  void operator=(const EndDtdEvent &); // undefined

  ConstPtr<Dtd> dtd_;

};

class EndLpdEvent : public MarkupEvent {

public:

  EndLpdEvent(const ConstPtr<Lpd> &, const Location &,

	      Markup *);

  void handle(EventHandler &);

  const Lpd &lpd() const;

  const ConstPtr<Lpd> &lpdPointer() const;

private:

  EndLpdEvent(const EndLpdEvent &); // undefined

  void operator=(const EndLpdEvent &); // undefined

  ConstPtr<Lpd> lpd_;

};

class EndPrologEvent : public LocatedEvent {

public:

  EndPrologEvent(const ConstPtr<Dtd> &dtd,

		 const ConstPtr<ComplexLpd> &lpd,

		 Vector<StringC> &simpleLinkNames,

		 Vector<AttributeList> &simpleLinkAttributes,

		 const Location &);

  EndPrologEvent(const ConstPtr<Dtd> &dtd,

		 const Location &);

  void handle(EventHandler &);

  const Dtd &dtd() const;

  const ConstPtr<Dtd> &dtdPointer() const;

  const ConstPtr<ComplexLpd> &lpdPointer() const;

  const Vector<StringC> &simpleLinkNames() const;

  const Vector<AttributeList> &simpleLinkAttributes() const;

private:

  EndPrologEvent(const EndPrologEvent &); // undefined

  void operator=(const EndPrologEvent &); // undefined

  ConstPtr<Dtd> dtd_;

  ConstPtr<ComplexLpd> lpd_;

  Vector<StringC> simpleLinkNames_;

  Vector<AttributeList> simpleLinkAttributes_;

};

class SgmlDeclEvent : public MarkupEvent {

public:

  // for an implied SGML declaration

  SgmlDeclEvent(const ConstPtr<Sd> &,

		const ConstPtr<Syntax> &syntax);

  // for an explicit SGML declaration

  SgmlDeclEvent(const ConstPtr<Sd> &,

		const ConstPtr<Syntax> &syntax,

		const ConstPtr<Syntax> &instanceSyntax,

		const ConstPtr<Sd> &refSd,

		const ConstPtr<Syntax> &refSyntax,

		Index nextIndex,

		const StringC &implySystemId,

		const Location &,

		Markup *);

  void handle(EventHandler &);

  const Sd &sd() const;

  const ConstPtr<Sd> &sdPointer() const;

  const Syntax &prologSyntax() const;

  const ConstPtr<Syntax> &prologSyntaxPointer() const;

  const Syntax &instanceSyntax() const;

  const ConstPtr<Syntax> &instanceSyntaxPointer() const;

  const ConstPtr<Sd> &refSdPointer() const;

  const ConstPtr<Syntax> &refSyntaxPointer() const;

  const StringC &implySystemId() const;

private:

  SgmlDeclEvent(const SgmlDeclEvent &);	// undefined

  void operator=(const SgmlDeclEvent &); // undefined

  ConstPtr<Sd> sd_;

  ConstPtr<Syntax> prologSyntax_;

  ConstPtr<Syntax> instanceSyntax_;

  ConstPtr<Sd> refSd_;

  ConstPtr<Syntax> refSyntax_;

  Index nextIndex_;

  StringC implySystemId_;

};

class CommentDeclEvent : public MarkupEvent {

public:

  CommentDeclEvent(const Location &, Markup *);

  void handle(EventHandler &);

private:

  CommentDeclEvent(const CommentDeclEvent &); // undefined

  void operator=(const CommentDeclEvent &);   // undefined

};

class SSepEvent : public ImmediateDataEvent {

public:

  SSepEvent(const Char *, size_t, const Location &, Boolean copy);

  void handle(EventHandler &);

private:

  SSepEvent(const SSepEvent &);	// undefined

  void operator=(const SSepEvent &); // undefined

};

class IgnoredRsEvent : public LocatedEvent {

public:

  IgnoredRsEvent(Char c, const Location &);

  void handle(EventHandler &);

  Char rs() const;

private:

  IgnoredRsEvent(const IgnoredRsEvent &); // undefined

  void operator=(const IgnoredRsEvent &); // undefined

  Char c_;

};

class IgnoredReEvent : public LocatedEvent {

public:

  IgnoredReEvent(Char c, const Location &, unsigned long serial);

  void handle(EventHandler &);

  Char re() const;

  unsigned long serial() const;

private:

  IgnoredReEvent(const IgnoredReEvent &); // undefined

  void operator=(const IgnoredReEvent &); // undefined

  unsigned long serial_;

  Char c_;

};

class ReEvent : public ImmediateDataEvent {

public:

  ReEvent(const Char *, const Location &, unsigned long serial);

  Boolean isRe(unsigned long &serial) const;

private:

  ReEvent(const ReEvent &);	// undefined

  void operator=(const ReEvent &); // undefined

  unsigned long serial_;

};

class ReOriginEvent : public LocatedEvent {

public:

  ReOriginEvent(Char c, const Location &, unsigned long serial);

  void handle(EventHandler &);

  Char re() const;

  unsigned long serial() const;

private:

  ReOriginEvent(const ReOriginEvent &);	// undefined

  void operator=(const ReOriginEvent &); // undefined

  unsigned long serial_;

  Char c_;

};

class IgnoredCharsEvent : public ImmediateDataEvent {

public:

  IgnoredCharsEvent(const Char *, size_t, const Location &, Boolean copy);

  void handle(EventHandler &);

private:

  IgnoredCharsEvent(const IgnoredCharsEvent &);	// undefined

  void operator=(const IgnoredCharsEvent &);	// undefined

};

class MarkedSectionEvent : public MarkupEvent {

public:

  enum Status { include, rcdata, cdata, ignore }; // in priority order

  MarkedSectionEvent(Type, Status, const Location &, Markup *);

  Status status() const;

private:

  MarkedSectionEvent(const MarkedSectionEvent &); // undefined

  void operator=(const MarkedSectionEvent &);	  // undefined

  Status status_;

};

class MarkedSectionStartEvent : public MarkedSectionEvent {

public:

  MarkedSectionStartEvent(Status, const Location &, Markup *);

  void handle(EventHandler &);

private:

  MarkedSectionStartEvent(const MarkedSectionStartEvent &); // undefined

  void operator=(const MarkedSectionStartEvent &);	    // undefined

};

class MarkedSectionEndEvent : public MarkedSectionEvent {

public:

  MarkedSectionEndEvent(Status, const Location &, Markup *);

  void handle(EventHandler &);

private:

  MarkedSectionEndEvent(const MarkedSectionEndEvent &); // undefined

  void operator=(const MarkedSectionEndEvent &);	    // undefined

};

class EntityStartEvent : public Event {

public:

  EntityStartEvent(const ConstPtr<EntityOrigin> &origin);

  void handle(EventHandler &);

  const Entity *entity() const;

  const ConstPtr<EntityOrigin> &entityOrigin() const;

private:

  EntityStartEvent(const EntityStartEvent &); // undefined

  void operator=(const EntityStartEvent &); // undefined

  ConstPtr<EntityOrigin> origin_;

};

class EntityEndEvent : public LocatedEvent {

public:

  EntityEndEvent(const Location &);

  void handle(EventHandler &);

private:

  EntityEndEvent(const EntityEndEvent &); // undefined

  void operator=(const EntityEndEvent &); // undefined

};

class EntityDeclEvent : public MarkupEvent {

public:

  EntityDeclEvent(const ConstPtr<Entity> &,

		  Boolean ignored,

		  const Location &,

		  Markup *);

  void handle(EventHandler &);

  const Entity &entity() const;

  const ConstPtr<Entity> &entityPointer() const;

  Boolean ignored() const;

  // The name of the entity will be empty if this is the default entity.

private:

  Boolean ignored_;

  // This will actually point to an external entity.

  ConstPtr<Entity> entity_;

};

class NotationDeclEvent : public MarkupEvent {

public:

  NotationDeclEvent(const ConstPtr<Notation> &,

		    const Location &,

		    Markup *);

  void handle(EventHandler &);

  const Notation &notation() const;

  const ConstPtr<Notation> &notationPointer() const;

private:

  NotationDeclEvent(const NotationDeclEvent &);	// undefined

  void operator=(const NotationDeclEvent &);	// undefined

  ConstPtr<Notation> notation_;

};

class ElementDeclEvent : public MarkupEvent {

public:

  ElementDeclEvent(Vector<const ElementType *> &elements,

		   const ConstPtr<Dtd> &,

		   const Location &,

		   Markup *);

  void handle(EventHandler &);

  const Vector<const ElementType *> &elements() const;

private:

  ElementDeclEvent(const ElementDeclEvent &); // undefined

  void operator=(const ElementDeclEvent &);   // undefined

  Vector<const ElementType *> elements_;

  ConstPtr<Dtd> dtd_;

};

class AttlistDeclEvent : public MarkupEvent {

public:

  AttlistDeclEvent(Vector<const ElementType *> &elements,

		   const ConstPtr<Dtd> &,

		   const Location &,

		   Markup *);

  void handle(EventHandler &);

  const Vector<const ElementType *> &elements() const;

private:

  AttlistDeclEvent(const AttlistDeclEvent &); // undefined

  void operator=(const AttlistDeclEvent &);   // undefined

  Vector<const ElementType *> elements_;

  ConstPtr<Dtd> dtd_;

};

class AttlistNotationDeclEvent : public MarkupEvent {

public:

  AttlistNotationDeclEvent(Vector<ConstPtr<Notation> > &notations,

			   const Location &,

			   Markup *);

  void handle(EventHandler &);

  const Vector<ConstPtr<Notation> > &notations() const;

private:

  AttlistNotationDeclEvent(const AttlistNotationDeclEvent &); // undefined

  void operator=(const AttlistDeclEvent &);		      // undefined

  Vector<ConstPtr<Notation> > notations_;

};

class LinkAttlistDeclEvent : public MarkupEvent {

public:

  LinkAttlistDeclEvent(Vector<const ElementType *> &elements,

		       const ConstPtr<Lpd> &,

		       const Location &,

		       Markup *);

  void handle(EventHandler &);

  const Vector<const ElementType *> &elements() const;

  const Lpd &lpd() const;

private:

  LinkAttlistDeclEvent(const LinkAttlistDeclEvent &); // undefined

  void operator=(const LinkAttlistDeclEvent &);   // undefined

  Vector<const ElementType *> elements_;

  ConstPtr<Lpd> lpd_;

};

class LinkDeclEvent : public MarkupEvent {

public:

  LinkDeclEvent(const LinkSet *linkSet,

		const ConstPtr<ComplexLpd> &,

		const Location &,

		Markup *);

  void handle(EventHandler &);

  const LinkSet *linkSet() const;

  const ComplexLpd &lpd() const;

private:

  LinkDeclEvent(const LinkDeclEvent &); // undefined

  void operator=(const LinkDeclEvent &); // undefined

  const LinkSet *linkSet_;

  ConstPtr<ComplexLpd> lpd_;

};

class IdLinkDeclEvent : public MarkupEvent {

public:

  IdLinkDeclEvent(const ConstPtr<ComplexLpd> &,

		  const Location &,

		  Markup *);

  void handle(EventHandler &);

  const ComplexLpd &lpd() const;

private:

  IdLinkDeclEvent(const IdLinkDeclEvent &); // undefined

  void operator=(const IdLinkDeclEvent &); // undefined

  ConstPtr<ComplexLpd> lpd_;

};

class ShortrefDeclEvent : public MarkupEvent {

public:

  ShortrefDeclEvent(const ShortReferenceMap *,

		    const ConstPtr<Dtd> &,

		    const Location &,

		    Markup *);

  void handle(EventHandler &);

  const ShortReferenceMap *map() const;

private:

  ShortrefDeclEvent(const ShortrefDeclEvent &);	// undefined

  void operator=(const ShortrefDeclEvent &);	// undefined

  const ShortReferenceMap *map_;

  ConstPtr<Dtd> dtd_;

};

class IgnoredMarkupEvent : public MarkupEvent {

public:

  IgnoredMarkupEvent(const Location &, Markup *);

  void handle(EventHandler &);

private:

  IgnoredMarkupEvent(const IgnoredMarkupEvent &); // undefined

  void operator=(const IgnoredMarkupEvent &);	  // undefined

};

// This is for an undeclared entity whose first occurrence

// is in the instance, when there is a default entity:

// ie it extends the namespace of general entities after

// the end of the prolog.

class EntityDefaultedEvent : public LocatedEvent {

public:

  EntityDefaultedEvent(const ConstPtr<Entity> &,

		       const Location &);

  void handle(EventHandler &);

  const Entity &entity() const;

  const ConstPtr<Entity> &entityPointer() const;

private:

  EntityDefaultedEvent(const EntityDefaultedEvent &); // undefined

  void operator=(const EntityDefaultedEvent &);	      // undefined

  ConstPtr<Entity> entity_;

};

class SgmlDeclEntityEvent : public LocatedEvent {

public:

  SgmlDeclEntityEvent(const PublicId &publicId,

		      PublicId::TextClass entityType,

		      const StringC &effectiveSystemId,

		      const Location &);

  void handle(EventHandler &);

  const PublicId &publicId() const;

  PublicId::TextClass entityType() const;

  const StringC &effectiveSystemId() const;

private:

  SgmlDeclEntityEvent(const SgmlDeclEntityEvent &); // undefined

  void operator=(const SgmlDeclEntityEvent &);	    // undefined

  PublicId publicId_;

  PublicId::TextClass entityType_;

  StringC effectiveSystemId_;

};

class SP_API EventHandler {

public:

  virtual ~EventHandler();

  virtual void message(MessageEvent *) = 0;

  virtual void data(DataEvent *);

  virtual void startElement(StartElementEvent *);

  virtual void endElement(EndElementEvent *);

  virtual void pi(PiEvent *);

  virtual void sdataEntity(SdataEntityEvent *);

  virtual void externalDataEntity(ExternalDataEntityEvent *);

  virtual void subdocEntity(SubdocEntityEvent *);

  virtual void nonSgmlChar(NonSgmlCharEvent *);

  virtual void appinfo(AppinfoEvent *);

  virtual void uselink(UselinkEvent *);

  virtual void usemap(UsemapEvent *);

  virtual void startDtd(StartDtdEvent *);

  virtual void endDtd(EndDtdEvent *);

  virtual void startLpd(StartLpdEvent *);

  virtual void endLpd(EndLpdEvent *);

  virtual void endProlog(EndPrologEvent *);

  virtual void sgmlDecl(SgmlDeclEvent *);

  virtual void commentDecl(CommentDeclEvent *);

  virtual void sSep(SSepEvent *);

  virtual void ignoredRs(IgnoredRsEvent *);

  virtual void ignoredRe(IgnoredReEvent *);

  virtual void reOrigin(ReOriginEvent *);

  virtual void ignoredChars(IgnoredCharsEvent *);

  virtual void markedSectionStart(MarkedSectionStartEvent *);

  virtual void markedSectionEnd(MarkedSectionEndEvent *);

  virtual void entityStart(EntityStartEvent *);

  virtual void entityEnd(EntityEndEvent *);

  virtual void notationDecl(NotationDeclEvent *);

  virtual void entityDecl(EntityDeclEvent *);

  virtual void elementDecl(ElementDeclEvent *);

  virtual void attlistDecl(AttlistDeclEvent *);

  virtual void linkAttlistDecl(LinkAttlistDeclEvent *);

  virtual void attlistNotationDecl(AttlistNotationDeclEvent *);

  virtual void linkDecl(LinkDeclEvent *);

  virtual void idLinkDecl(IdLinkDeclEvent *);

  virtual void shortrefDecl(ShortrefDeclEvent *);

  virtual void ignoredMarkup(IgnoredMarkupEvent *);

  virtual void entityDefaulted(EntityDefaultedEvent *);

  virtual void inputClosed(InputSource *in);

  virtual void inputOpened(InputSource *in);

  virtual void sgmlDeclEntity(SgmlDeclEntityEvent *);

};

inline

Event::Event(Type type)

: type_(type)

{

}

inline

Event::~Event()

{

}