class REXML::Parsers::PullEvent

event.
but are identical to the arguments passed to +StreamListener+s for each
type accessor. The contents of this object vary from event to event,
and the type is given either by the …? methods, or by accessing the
A parsing event. The contents of the event are accessed as an +Array?,

def []( start, endd=nil) 

def []( start, endd=nil)
  if start.kind_of? Range
    @contents.slice( start.begin+1 .. start.end )
  elsif start.kind_of? Numeric
    if endd.nil?
      @contents.slice( start+1 )
    else
      @contents.slice( start+1, endd )
    end
  else
    raise "Illegal argument #{start.inspect} (#{start.class})"
  end
end

def attlistdecl?

Content: [ String text ] 
def attlistdecl?
  @contents[0] == :attlistdecl
end

def cdata?

Content: [ String text ] 
def cdata?
  @contents[0] == :cdata
end

def comment?

Content: [ String text ] 
def comment?
  @contents[0] == :comment
end

def doctype?

Content: [ String name, String pub_sys, String long_name, String uri ] 
def doctype?
  @contents[0] == :start_doctype
end

def elementdecl?

Content: [ String text ] 
def elementdecl?
  @contents[0] == :elementdecl
end

def end_element?

Content: [ String tag_name ] 
def end_element?
  @contents[0] == :end_element
end

def entity?

Content: [ String text ] 
def entity?
  @contents[0] == :entity
end

def entitydecl?

Content: [ String text ]
[ String name, String value ]
* If the entity declaration is an internal entity:

content yourself. However, the following is true:
anything. There's no way to normalize it; you'll have to interpret the
Due to the wonders of DTDs, an entity declaration can be just about 
def entitydecl?
  @contents[0] == :entitydecl
end

def error? 

def error?
  @contents[0] == :error
end

def event_type 

def event_type
  @contents[0]
end

def initialize(arg)

:notationdecl, :entity, :cdata, :xmldecl, or :error.
:processing_instruction, :comment, :doctype, :attlistdecl, :entitydecl,
The type of this event. Will be one of :tag_start, :tag_end, :text, 
def initialize(arg)
  @contents = arg
end

def inspect 

def inspect
  @contents[0].to_s + ": " + @contents[1..-1].inspect
end

def instruction?

Content: [ String text ] 
def instruction?
  @contents[0] == :processing_instruction
end

def notationdecl?

Content: [ String text ] 
def notationdecl?
  @contents[0] == :notationdecl
end

def start_element?

Content: [ String tag_name, Hash attributes ] 
def start_element?
  @contents[0] == :start_element
end

def text?

Content: [ String raw_text, String unnormalized_text ] 
def text?
  @contents[0] == :text
end

def xmldecl?

Content: [ String version, String encoding, String standalone ] 
def xmldecl?
  @contents[0] == :xmldecl
end