voruby 1.1.1 → 2.0.0

data/lib/voruby/stc/support.rb

@@ -0,0 +1,2 @@
+require 'rexml/document'
+require 'voruby/misc'

data/lib/voruby/ucd/ucd.rb

@@ -0,0 +1,173 @@
+require 'soap/rpc/driver'
+require 'ostruct'
+
+module VORuby
+  # Unified Content Descriptors[http://www.ivoa.net/Documents/latest/UCD.html] or UCDs constitute a controlled vocabulary
+  # used throughout the VO.  This class provides some useful methods for dealing with them.
+  class UCD
+    attr_accessor :check_availability
+    
+    # Create a new UCD resolver.
+    # <tt>options</tt> is a hash with the following keys:
+    #
+    # [<tt>:end_point</tt>]     the UCD SOAP endpoint to use (default: http://cdsws.u-strasbg.fr/axis/services/UCD)
+    # [<tt>:check_availability</tt>] whether to try to determine if the sesame service is available or not before each name resolution (default: false)
+    #
+    #   ucd = UCD.new(
+    #     :end_point => 'ttp://vizier.hia.nrc.ca:8080/axis/services/UCD' # maybe we're in Canada...
+    #     :check_availability => true # and we want to always check the availability of the service
+    #   )
+    def initialize(options={})
+      self.end_point = options[:end_point] || 'http://cdsws.u-strasbg.fr/axis/services/UCD'
+      self.check_availability = options[:check_availability] || false
+    end
+    
+    # The "end-point" or location of the UCD resolver's webservice.
+    def end_point
+      @end_point
+    end
+    
+    # Set the end-point or location of the UCD resolver's webservice.
+    #   ucd.end_point = 'http://vizier.hia.nrc.ca:8080/axis/services/UCD'
+    def end_point=(epoint)
+      @end_point = epoint
+      
+      @resolver = SOAP::RPC::Driver.new(@end_point)
+      @resolver.add_rpc_method('translate', 'ucd')
+      @resolver.add_rpc_method('assign', 'descr')
+      @resolver.add_rpc_method('explain', 'ucd')
+      @resolver.add_rpc_method('resolveUCD', 'ucd')
+      @resolver.add_rpc_method('validate', 'ucd')
+      @resolver.add_rpc_method('upgrade','ucd')
+      @resolver.add_rpc_method('getAvailability')
+    end
+    
+    # Translate an old-style UCD1 into it's newer UCD1+ form.
+    # Returns <tt>nil</tt> if the UCD is untranslatable.
+    #
+    #   ucd.translate('POS_EQ_RA_MAIN') # => 'pos.eq.ra;meta.main'
+    def translate(ucd)
+      raise "UCD resolver at #{self.end_point} is not currently available" if self.check_availability and !self.available?
+      
+      ucd_plus = @resolver.translate(ucd).strip
+      ucd_plus.match('Could not translate') ? nil : ucd_plus
+    end
+    
+    # Convenience class method for #translate.
+    def self.translate(ucd, options={})
+      self.new(options).translate(ucd)
+    end
+    
+    # Given a text description of a parameter (i.e. V magnitude), find
+    # a likely corresponding UCD1+.  Returns <tt>nil</tt> if no UCD is found.
+    #
+    #   ucd.assign('V magnitude')  # => 'phot.mag;em.opt.V'
+    def assign(descr)
+      raise "UCD resolver at #{self.end_point} is not currently available" if self.check_availability and !self.available?
+      
+      ucd_plus = @resolver.assign(descr).strip
+      ucd_plus.match('Could not find') ? nil : ucd_plus
+    end
+    
+    # Convenience class method for #assign.
+    def self.assign(descr, options={})
+      self.new(options).assign(descr)
+    end
+    
+    # Given a UCD, discover a human-readable description.
+    # <tt>version</tt> may be '1+' (the default) for a UCD1+ or
+    # '1' for an old-style UCD.
+    # Returns <tt>nil</tt> if the UCD is not recognized.
+    #
+    #   ucd.explain('ivoa:phot.mag;em.opt.B') # => 'Photometric magnitude / Optical band between 400 and 500 nm'
+    #   ucd.explain('PHOT_JHN_V', '1') # => 'Johnson magnitude V (JHN)'
+    def explain(ucd, version='1+')
+      version ||= '1+'
+      raise "UCD resolver at #{self.end_point} is not currently available" if self.check_availability and !self.available?
+      
+      descr = case version
+        when '1'
+          @resolver.resolveUCD(ucd)
+        else
+          @resolver.explain(ucd)
+        end
+        
+      (descr.match('Non-standard UCD') or descr.match('Invalid UCD')) ? nil : descr.strip
+    end
+    
+    # Convenience class method for #explain.
+    def self.explain(ucd, version='1+', options={})
+      self.new(options).explain(ucd, version)
+    end
+    
+    # Validate a specifed UCD1+.  Returns an object that responds
+    # to a #code method and a human-readable list of of error strings.
+    # A <tt>code</tt> of 0 implies the UCD is valid.  Possible combinations
+    # arise from bitwise-OR'ing the following:
+    #
+    # * 1: warning indicating use of non-standard namespace (not ivoa:)
+    # * 2: use of deprecated word
+    # * 4: use of non-existing word
+    # * 8: syntax error (extra space or unallowed character)
+    #
+    #   result = ucd.validate('ivob:phot.mag;em.opt.Z')
+    #   puts result.code # => 5
+    #   puts result.errors => ["use of non-standard namespace 'ivob'", "invalid UCD word 'em.opt.Z'"]
+    def validate(ucd)
+      raise "UCD resolver at #{self.end_point} is not currently available" if self.check_availability and !self.available?
+      
+      error = @resolver.validate(ucd).strip
+      parts = error.split(/\s*\*\*\*\*\s*/)
+      
+      OpenStruct.new(
+        :code => parts.first.to_i,
+        :errors => parts[1..-1]
+      )
+    end
+    
+    # Convenience class method for #validate.
+    def self.validate(ucd, options={})
+      self.new(options).validate(ucd)
+    end
+    
+    # Returns true or false depending on whether a UCD1+ is
+    # valid.  This is the same checking the <tt>code</tt> on the object
+    # that #validate returns.
+    #
+    #   ucd.valid?('ivob:phot.mag;em.opt.Z') # => false
+    #   ucd.valid?('ivoa:phot.mag;em.opt.B') # => true
+    def valid?(ucd)
+      self.validate(ucd).code == 0 ? true : false
+    end
+    
+    # Convenience class method for #valid?.
+    def self.valid?(ucd, options={})
+      self.new(options).valid?(ucd)
+    end
+    
+    # Find a valid UCD1+ corresponding to a deprecated word.
+    #
+    #   ucd.upgrade('pos.gal.lat') # => 'pos.galactic.lat'
+    def upgrade(ucd)
+      raise "UCD resolver at #{self.end_point} is not currently available" if self.check_availability and !self.available?
+      @resolver.upgrade(ucd).strip
+    end
+    
+    # Convenience class method for #upgrade.
+    def self.upgrade(ucd, options={})
+      self.new(options).upgrade(ucd)
+    end
+    
+    # Checks to see whether the UCD resolver is available.
+    # At this point it's assumed the service is present at
+    # the location specified by #end_point.  This just checks
+    # to see whether sesame reports itself as available or not.
+    def available?
+      # We don't use an XML parser here because (as of 2007-01-04)
+      # the validTo tag isn't closed properly, rendering the XML
+      # malformed.
+      result = @resolver.getAvailability
+      result.match(/<available>\s*(.*)\s*<\/available>/)[1] == 'true'
+    end
+  end
+end

data/lib/voruby/voevent/1.1/voevent.rb

@@ -0,0 +1,1124 @@
+require 'voruby/voevent/support'
+require 'voruby/stc/1.30/stc'
+include VORuby::STC::V1_30
+
+module VORuby
+  module VOEvent
+    module V1_1
+      include XMLUtilities
+      
+      class Base
+        include SerializableToXml
+      end
+    
+      # External content.
+      class Reference < Base
+        attr_accessor :type, :name
+        attr_reader :uri
+        
+        def initialize(uri, type='url', name=nil)
+          self.uri = uri
+          self.type = type || 'url'
+          self.name = name
+        end
+        
+        def uri=(u)
+          raise_argument_required_error('URI') if !u
+          @uri = u.is_a?(URI) ? u : URI.parse(u.to_s)
+        end
+        
+        def ==(r)
+          self.uri == r.uri and
+          self.type == r.type and
+          self.name == r.name
+        end
+        
+        def to_xml(name=nil)
+          el = element(name)
+          
+          el.attributes["#{obj_ns.prefix}:uri"] = self.uri.to_s
+          el.attributes["#{obj_ns.prefix}:name"] = self.name.to_s if self.name
+          el.attributes["#{obj_ns.prefix}:type"] = self.type.to_s if self.type
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          name = root.attributes.get_attribute_ns(obj_ns.uri, 'name')
+          type = root.attributes.get_attribute_ns(obj_ns.uri, 'type')
+          
+          self.new(
+            URI.parse(root.attributes.get_attribute_ns(obj_ns.uri, 'uri').value),
+            type ? type.value : nil,
+            name ? name.value : nil
+          )
+        end
+      end
+      
+      # Human readable text.
+      class Description < Base
+        attr_accessor :format
+        attr_reader :value
+        
+        def initialize(value, format='text/plain')
+          self.value = value
+          self.format = format || 'text/plain'
+        end
+        
+        def value=(v)
+          raise_argument_required_error('description value') if !v
+          @value = v.to_s
+        end
+        
+        def ==(d)
+          self.value == d.value and
+          self.format == d.format
+        end
+        
+        def to_xml(name=nil)
+          el = element(name)
+          
+          el.text = self.value.to_s
+          el.attributes["#{obj_ns.prefix}:format"] = self.format.to_s if self.format
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          format = root.attributes.get_attribute_ns(obj_ns.uri, 'format')
+          
+          self.new(
+            root.texts.join('').strip,
+            format ? format.value : nil
+          )
+        end
+      end
+      
+      class Cite < Enumeration
+        def self.choices; ['followup', 'supersedes', 'retraction'] end
+      end
+      
+      class EventIVORN < Base
+        attr_reader :uri, :cite
+        
+        def initialize(uri, cite)
+          self.uri = uri
+          self.cite = cite
+        end
+        
+        def uri=(u)
+          raise_argument_required_error('URI') if !u
+          @uri = u.is_a?(URI) ? u : URI.parse(u.to_s)
+        end
+        
+        def cite=(c)
+          raise_argument_required_error('cite') if !c
+          
+          c = Cite.new(c) if c.is_a?(String)
+          raise_type_mismatch_error(c, Cite)
+          
+          @cite = c
+        end
+        
+        def ==(i)
+          self.uri == i.uri and
+          self.cite == i.cite
+        end
+        
+        def to_xml(name=nil)
+          el = element(name)
+          
+          el.text = self.uri.to_s
+          el.attributes["#{obj_ns.prefix}:cite"] = self.cite.to_s
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            root.text,
+            Cite.new(root.attributes.get_attribute_ns(obj_ns.uri, 'cite').value)
+          )
+        end
+      end
+      
+      class DescriptionList < TypedArray
+        def self.restricted_to; [Description] end
+      end
+      
+      class ReferenceList < TypedArray
+        def self.restricted_to; [Reference] end
+      end
+      
+      class Described < Base
+        attr_reader :descriptions, :references
+        
+        def initialize(descriptions=nil, references=nil)
+          self.descriptions = descriptions
+          self.references = references
+        end
+      
+        def descriptions=(ds)
+          if ds
+            ds = DescriptionList.new(ds) if ds.class == Array
+            raise_type_mismatch_error(ds, DescriptionList)
+          end
+        
+          @descriptions = ds
+        end
+      
+        def references=(rs)
+          if rs
+            rs = ReferenceList.new(rs) if rs.class == Array
+            raise_type_mismatch_error(rs, ReferenceList)
+          end
+        
+          @references = rs
+        end
+      
+        def ==(h)
+          self.descriptions == h.descriptions and
+          self.references == h.references
+        end
+      
+        def to_xml(name=nil)
+          el = element(name)
+        
+          self.descriptions.each{ |d| el.add_element(d.to_xml('Description')) } if self.descriptions
+          self.references.each{ |r| el.add_element(r.to_xml('Reference')) } if self.references
+        
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.described_from_xml(root)
+          descrs = REXML::XPath.match(root, 'x:Description', {'x' => obj_ns.uri})
+          descrs = nil if descrs.size == 0
+          
+          refs = REXML::XPath.match(root, 'x:Reference', {'x' => obj_ns.uri})
+          refs = nil if refs.size == 0
+          
+          [
+            descrs ? DescriptionList.new(descrs.collect{ |d| Description.from_xml(d) }) : nil,
+            refs ? ReferenceList.new(refs.collect{ |r| Reference.from_xml(r) }) : nil
+          ]
+        end
+      
+        def self.from_xml(xml)
+          root = element_from(xml)
+          self.new(*described_from_xml(root))
+        end
+      end
+      
+      # Follow-up Observations.
+      class Citations < Described
+        class EventIVORNList < TypedArray
+          def self.restricted_to; [EventIVORN] end
+          def self.minimum_length; 1 end
+        end
+        
+        attr_reader :event_ivorns
+        
+        def initialize(ivorns, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.event_ivorns = ivorns
+        end
+        
+        def event_ivorns=(eis)
+          raise_argument_required_error('event IVORNs') if !eis
+          
+          eis = EventIVORNList.new(eis) if eis.class == Array
+          raise_type_mismatch_error(eis, EventIVORNList)
+          
+          @event_ivorns = eis
+        end
+
+        def ==(c)
+          super(c) and
+          self.event_ivorns == c.event_ivorns
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.event_ivorns.each{ |i| el.add_element(i.to_xml('EventIVORN')) }
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          ivorns = REXML::XPath.match(root, 'x:EventIVORN', {'x' => obj_ns.uri})
+          ivorns = nil if ivorns.size == 0
+          
+          self.new(
+            ivorns ? EventIVORNList.new(ivorns.collect{ |e| EventIVORN.from_xml(e) }) : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+      class NameList < TypedArray
+        def self.restricted_to; [String] end
+      end
+      
+      class ConceptList < TypedArray
+        def self.restricted_to; [String] end
+      end
+      
+      class Inference < Described
+        attr_reader :names, :concepts, :probability, :relation
+        
+        def initialize(names, concepts, probability=nil, relation=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.names = names
+          self.concepts = concepts
+          self.probability = probability
+          self.relation = relation
+        end
+        
+        def names=(ns)
+          if ns
+            ns = NameList.new(ns) if ns.class == Array
+            raise_type_mismatch_error(ns, NameList)
+          end
+          
+          @names = ns
+        end
+        
+        def concepts=(cs)
+          if cs
+            cs = ConceptList.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, ConceptList)
+          end
+          
+          @concepts = cs
+        end
+        
+        def probability=(p)
+          if p
+            p = Float(p)
+            raise 'float must be between 0.0 and 1.0' if p < 0.0 or p > 1.0
+          end
+          
+          @probability = p
+        end
+        
+        def relation=(r)
+          @relation = r ? r.to_s : nil
+        end
+        
+        def ==(i)
+          super(i) and
+          self.names == i.names and
+          self.concepts == i.concepts and
+          self.probability == i.probability and
+          self.relation == i.relation
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.names.each{ |n|
+              name_el = REXML::Element.new("#{obj_ns.prefix}:Name")
+              name_el.text = n
+              el.add_element(name_el)
+          } if self.names
+          
+          self.concepts.each{ |c|
+            concept_el = REXML::Element.new("#{obj_ns.prefix}:Concept")
+            concept_el.text = c
+            el.add_element(concept_el)
+          } if self.concepts
+          
+          el.attributes["#{obj_ns.prefix}:probability"] = self.probability.to_s if self.probability
+          el.attributes["#{obj_ns.prefix}:relation"] = self.relation if self.relation
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          names = REXML::XPath.match(root, 'x:Name', {'x' => obj_ns.uri})
+          names = nil if names.size == 0
+          
+          concepts = REXML::XPath.match(root, 'x:Concept', {'x' => obj_ns.uri})
+          concepts = nil if concepts.size == 0
+          
+          probability = root.attributes.get_attribute_ns(obj_ns.uri, 'probability')
+          relation = root.attributes.get_attribute_ns(obj_ns.uri, 'relation')
+          
+          self.new(
+            names ? NameList.new(names.collect{ |name| name.text }) : nil,
+            concepts ? ConceptList.new(concepts.collect{ |concept| concept.text }) : nil,
+            probability ? Float(probability.value) : nil,
+            relation ? relation.value : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+      class InferenceList < TypedArray
+        def self.restricted_to; [Inference] end
+      end
+      
+      # Initial scientific assessment.
+      class Why < Described
+        attr_reader :inferences, :importance, :expires, :names, :concepts
+        
+        def initialize(inferences, importance=nil, expires=nil, names=nil, concepts=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.inferences = inferences
+          self.importance = importance
+          self.expires = expires
+          self.names = names
+          self.concepts = concepts
+        end
+        
+        def inferences=(is)
+          if is
+            is = InferenceList.new(is) if is.class == Array
+            raise_type_mismatch_error(is, InferenceList)
+          end
+          
+          @inferences = is
+        end
+        
+        def importance=(i)
+          i = Float(i) if i
+          @importance = i
+        end
+        
+        def expires=(e)
+          if e
+            e = DateTime.parse(e) if e.is_a?(String)
+            raise_type_mismatch_error(e, DateTime)
+          end
+          
+          @expires = e
+        end
+        
+        def names=(ns)
+          if ns
+            ns = NameList.new(ns) if ns.class == Array
+            raise_type_mismatch_error(ns, NameList)
+          end
+          
+          @names = ns
+        end
+        
+        def concepts=(cs)
+          if cs
+            cs = ConceptList.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, ConceptList)
+          end
+          
+          @concepts = cs
+        end
+        
+        def ==(w)
+          super(w) and
+          self.inferences == w.inferences and
+          self.importance == w.importance and
+          self.expires == w.expires and
+          self.names == w.names and
+          self.concepts == w.concepts
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.inferences.each{ |i| el.add_element(i.to_xml('Inference')) } if self.inferences
+          
+          el.attributes["#{obj_ns.prefix}:importance"] = self.importance.to_s if self.importance
+          el.attributes["#{obj_ns.prefix}:expires"] = self.expires.strftime('%Y-%m-%dT%H:%M:%S') if self.expires
+          
+          self.names.each{ |n|
+              name_el = REXML::Element.new("#{obj_ns.prefix}:Name")
+              name_el.text = n
+              el.add_element(name_el)
+          } if self.names
+          
+          self.concepts.each{ |c|
+            concept_el = REXML::Element.new("#{obj_ns.prefix}:Concept")
+            concept_el.text = c
+            el.add_element(concept_el)
+          } if self.concepts
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          inferences = REXML::XPath.match(root, 'x:Inference', {'x' => obj_ns.uri})
+          inferences = nil if inferences.size == 0
+          
+          names = REXML::XPath.match(root, 'x:Name', {'x' => obj_ns.uri})
+          names = nil if names.size == 0
+          
+          concepts = REXML::XPath.match(root, 'x:Concept', {'x' => obj_ns.uri})
+          concepts = nil if concepts.size == 0
+          
+          importance = root.attributes.get_attribute_ns(obj_ns.uri, 'importance')
+          expires = root.attributes.get_attribute_ns(obj_ns.uri, 'expires')
+          
+          self.new(
+            inferences ? InferenceList.new(inferences.collect{ |i| Inference.from_xml(i) }) : nil,
+            importance ? Float(importance.value) : nil,
+            expires ? DateTime.parse(expires.value) : nil,
+            names ? NameList.new(names.collect{ |n| n.text }) : nil,
+            concepts ? ConceptList.new(concepts.collect{ |c| c.text }) : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+     
+      # Instrument Configuration, references to RTML documents.
+      class How < Described; end
+     
+      # Space-Time Coordinates, uses the VO STC schema.
+      class WhereWhen < Described
+        class ObsDataLocationList < TypedArray
+          def self.restricted_to; [ObsDataLocation] end
+        end
+        
+        attr_reader :obs_data_locations
+        
+        def initialize(obs_data_locations=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.obs_data_locations = obs_data_locations
+        end
+        
+        def obs_data_locations=(odls)
+          if odls
+            odls = ObsDataLocationList.new(odls) if odls.class == Array
+            raise_type_mismatch_error(odls, ObsDataLocationList)
+          end
+          
+          @obs_data_locations = odls
+        end
+        
+        def ==(w)
+          super(w) and
+          self.obs_data_locations == w.obs_data_locations
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.obs_data_locations.each{ |l| el.add_element(l.to_xml) } if self.obs_data_locations
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          locs = REXML::XPath.match(root, 'x:ObsDataLocation', {'x' => obj_ns('VORuby::STC::V1_30').uri})
+          locs = nil if locs.size == 0
+          
+          self.new(
+            locs ? ObsDataLocationList.new(locs.collect{ |l| ObsDataLocation.from_xml(l) }) : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+      class Param < Base
+        attr_reader :name, :ucd, :value, :unit
+        
+        def initialize(name, value, ucd=nil, unit=nil)
+          self.name = name
+          self.value = value
+          self.ucd = ucd
+          self.unit = unit
+        end
+        
+        def name=(n)
+          @name = n ? n.to_s : nil
+        end
+        
+        def value=(v)
+          @value = v ? v.to_s : nil
+        end
+        
+        def ucd=(u)
+          @ucd = u ? u.to_s : nil
+        end
+        
+        def unit=(u)
+          @unit = u ? u.to_s : nil
+        end
+        
+        def ==(p)
+          self.name == p.name and
+          self.value == p.value and
+          self.ucd == p.ucd and
+          self.unit == p.unit
+        end
+        
+        def to_xml(name=nil)
+          el = element(name)
+          
+          el.attributes["#{obj_ns.prefix}:name"] = self.name if self.name
+          el.attributes["#{obj_ns.prefix}:value"] = self.value if self.value
+          el.attributes["#{obj_ns.prefix}:ucd"] = self.ucd if self.ucd
+          el.attributes["#{obj_ns.prefix}:unit"] = self.unit if self.unit
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          name = root.attributes.get_attribute_ns(obj_ns.uri, 'name')
+          value = root.attributes.get_attribute_ns(obj_ns.uri, 'value')
+          ucd = root.attributes.get_attribute_ns(obj_ns.uri, 'ucd')
+          unit = root.attributes.get_attribute_ns(obj_ns.uri, 'unit')
+          
+          self.new(
+            name ? name.value : nil,
+            value ? value.value : nil,
+            ucd ? ucd.value : nil,
+            unit ? unit.value : nil
+          )
+        end
+      end
+      
+      class ParamList < TypedArray
+        def self.restriced_to; [Param] end
+      end
+      
+      class Group < Described
+        attr_reader :params, :name, :type
+        
+        def initialize(params, name=nil, type=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.params = params
+          self.name = name
+          self.type = type
+        end
+        
+        def params=(ps)
+          if ps
+            ps = ParamList.new(ps) if ps.class == Array
+            raise_type_mismatch_error(ps, ParamList)
+          end
+          
+          @params = ps
+        end
+        
+        def name=(n)
+          @name = n ? n.to_s : nil
+        end
+        
+        def type=(t)
+          @type = t ? t.to_s : nil
+        end
+        
+        def ==(g)
+          super(g) and
+          self.params == g.params and
+          self.name == g.name and
+          self.type == g.type
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:name"] = self.name if self.name
+          el.attributes["#{obj_ns.prefix}:type"] = self.type if self.type
+          
+          self.params.each{ |p| el.add_element(p.to_xml('Param')) } if self.params
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          params = REXML::XPath.match(root, 'x:Param', {'x' => obj_ns.uri})
+          params = nil if params.size == 0
+          
+          name = root.attributes.get_attribute_ns(obj_ns.uri, 'name')
+          type = root.attributes.get_attribute_ns(obj_ns.uri, 'type')
+          
+          self.new(
+            params ? ParamList.new(params.collect{ |p| Param.from_xml(p) }) : nil,
+            name ? name.value : nil,
+            type ? type.value : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+      class GroupList < TypedArray
+        def self.restricted_to; [Group] end
+      end
+      
+      # Event characterization.
+      class What < Described
+        attr_reader :params, :groups
+        
+        def initialize(groups, params=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.groups = groups
+          self.params = params
+        end
+        
+        def groups=(gs)
+          if gs
+            gs = GroupList.new(gs) if gs.class == Array
+            raise_type_mismatch_error(gs, GroupList)
+          end
+          
+          @groups = gs
+        end
+        
+        def params=(ps)
+          if ps
+            ps = ParamList.new(ps) if ps.class == Array
+            raise_type_mismatch_error(ps, ParamList)
+          end
+          
+          @params = ps
+        end
+        
+        def ==(w)
+          super(w) and
+          self.groups == w.groups and
+          self.params == w.params
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.groups.each{ |g| el.add_element(g.to_xml('Group')) } if self.groups
+          self.params.each{ |p| el.add_element(p.to_xml('Param')) } if self.params
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          groups = REXML::XPath.match(root, 'x:Group', {'x' => obj_ns.uri})
+          groups = nil if groups.size == 0
+          
+          params = REXML::XPath.match(root, 'x:Param', {'x' => obj_ns.uri})
+          params = nil if params.size == 0
+          
+          self.new(
+            groups ? GroupList.new(groups.collect{ |g| Group.from_xml(g) }) : nil,
+            params ? ParamList.new(params.collect{ |p| Param.from_xml(p) }) : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+      class Author < Base
+        class StringList < TypedArray
+          def self.restriced_to; [String] end
+        end
+        
+        attr_reader :titles, :short_names, :logo_urls, :contact_names,
+          :contact_emails, :contact_phones, :contributors
+          
+        def initialize(options={})
+          options.each{ |key, value| send("#{key}=", value) }
+        end
+        
+        def titles=(ts)
+          if ts
+            ts = StringList.new(ts) if ts.class == Array
+            raise_type_mismatch_error(ts, StringList)
+          end
+          
+          @titles = ts
+        end
+        
+        def short_names=(sns)
+          if sns
+            sns = StringList.new(sns) if sns.class == Array
+            raise_type_mismatch_error(sns, StringList)
+          end
+          
+          @short_names = sns
+        end
+        
+        def logo_urls=(lus)
+          if lus
+            lus = StringList.new(lus) if lus.class == Array
+            raise_type_mismatch_error(lus, StringList)
+          end
+          
+          @logo_urls = lus
+        end
+        
+        def contact_names=(cns)
+          if cns
+            cns = StringList.new(cns) if cns.class == Array
+            raise_type_mismatch_error(cns, StringList)
+          end
+          
+          @contact_names = cns
+        end
+        
+        def contact_emails=(ces)
+          if ces
+            ces = StringList.new(ces) if ces.class == Array
+            raise_type_mismatch_error(ces, StringList)
+          end
+
+          @contact_emails = ces
+        end
+          
+        def contact_phones=(cps)
+          if cps
+            cps = StringList.new(cps) if cps.class == Array
+            raise_type_mismatch_error(cps, StringList)
+          end
+
+          @contact_phones = cps
+        end 
+        
+        def contributors=(cs)
+          if cs
+            cs = StringList.new(cs) if cs.class == Array
+            raise_type_mismatch_error(cs, StringList)
+          end
+
+          @contributors = cs
+        end
+        
+        def ==(a)
+          self.titles == a.titles and
+          self.short_names == a.short_names and
+          self.logo_urls == a.logo_urls and
+          self.contact_names == a.contact_names and
+          self.contact_emails == a.contact_emails and
+          self.contact_phones == a.contact_phones and
+          self.contributors == a.contributors
+        end
+        
+        def to_xml(name=nil)
+          el = element(name)
+          
+          self.titles.each { |t|
+            e = REXML::Element.new("#{obj_ns.prefix}:title")
+            e.text = t
+            el.add_element(e)
+          } if self.titles
+          
+          self.short_names.each{ |n|
+            e = REXML::Element.new("#{obj_ns.prefix}:shortName")
+            e.text = n
+            el.add_element(e)
+          } if self.short_names
+          
+          self.logo_urls.each{ |u|
+            e = REXML::Element.new("#{obj_ns.prefix}:logoURL")
+            e.text = u
+            el.add_element(e)
+          } if self.logo_urls
+          
+          self.contact_names.each{ |n|
+            e = REXML::Element.new("#{obj_ns.prefix}:contactName")
+            e.text = n
+            el.add_element(e)
+          } if self.contact_names
+          
+          self.contact_emails.each{ |m|
+            e = REXML::Element.new("#{obj_ns.prefix}:contactEmail")
+            e.text = m
+            el.add_element(e)
+          } if self.contact_emails
+          
+          self.contact_phones.each{ |p|
+            e = REXML::Element.new("#{obj_ns.prefix}:contactPhone")
+            e.text = p
+            el.add_element(e)
+          } if self.contact_phones
+          
+          self.contributors.each{ |c|
+            e = REXML::Element.new("#{obj_ns.prefix}:contributor")
+            e.text = c
+            el.add_element(e)
+          } if self.contributors
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          titles = REXML::XPath.match(root, 'x:title', {'x' => obj_ns.uri})
+          titles = nil if titles.size == 0
+          
+          short_names = REXML::XPath.match(root, 'x:shortName', {'x' => obj_ns.uri})
+          short_names = nil if short_names.size == 0
+          
+          logo_urls = REXML::XPath.match(root, 'x:logoURL', {'x' => obj_ns.uri})
+          logo_urls = nil if logo_urls.size == 0
+          
+          contact_names = REXML::XPath.match(root, 'x:contactName', {'x' => obj_ns.uri})
+          contact_names = nil if contact_names.size == 0
+          
+          contact_emails = REXML::XPath.match(root, 'x:contactEmail', {'x' => obj_ns.uri})
+          contact_emails = nil if contact_emails.size == 0
+          
+          contact_phones = REXML::XPath.match(root, 'x:contactPhone', {'x' => obj_ns.uri})
+          contact_phones = nil if contact_phones.size == 0
+          
+          contributors = REXML::XPath.match(root, 'x:contributor', {'x' => obj_ns.uri})
+          contributors = nil if contributors.size == 0
+          
+          self.new(
+            :titles => titles ? StringList.new(titles.collect{ |t| t.text }) : nil,
+            :short_names => short_names ? StringList.new(short_names.collect{ |n| n.text }) : nil,
+            :logo_urls => logo_urls ? StringList.new(logo_urls.collect{ |u| u.text }) : nil,
+            :contact_names => contact_names ? StringList.new(contact_names.collect{ |n| n.text }) : nil,
+            :contact_emails => contact_emails ? StringList.new(contact_emails.collect{ |e| e.text }) : nil,
+            :contact_phones => contact_phones ? StringList.new(contact_phones.collect{ |p| p.text }) : nil,
+            :contributors => contributors ? StringList.new(contributors.collect{ |c| c.text }) : nil
+          )
+        end
+      end
+      
+      class Who < Described
+        class IVORNList < TypedArray
+          def self.restricted_to; [URI] end
+        end
+        
+        class DateTimeList < TypedArray
+          def self.restricted_to; [DateTime] end
+        end
+        
+        class AuthorList < TypedArray
+          def self.restricted_to; [Author] end
+        end
+        
+        attr_reader :author_ivorns, :dates, :authors
+        
+        def initialize(author_ivorns, dates, authors=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.author_ivorns = author_ivorns
+          self.dates = dates
+          self.authors = authors
+        end
+        
+        def author_ivorns=(ais)
+          if ais
+            ais = IVORNList.new(ais) if ais.class == Array
+            raise_type_mismatch_error(ais, IVORNList)
+          end
+          
+          @author_ivorns = ais
+        end
+        
+        def dates=(ds)
+          if ds
+            ds = DateTimeList.new(ds) if ds.class == Array
+            raise_type_mismatch_error(ds, DateTimeList)
+          end
+          
+          @dates = ds
+        end
+        
+        def authors=(as)
+          if as
+            as = AuthorList.new(as) if as.class == Array
+            raise_type_mismatch_error(as, AuthorList)
+          end
+          
+          @authors = as
+        end
+        
+        def ==(w)
+          super(w) and
+          self.author_ivorns == w.author_ivorns and
+          self.dates == w.dates and
+          self.authors == w.authors
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.author_ivorns.each{ |i|
+            e = REXML::Element.new("#{obj_ns.prefix}:AuthorIVORN")
+            e.text = i.to_s
+            el.add_element(e)
+          } if self.author_ivorns
+          
+          self.dates.each{ |d|
+            e = REXML::Element.new("#{obj_ns.prefix}:Date")
+            e.text = d.to_s
+            el.add_element(e)
+          } if self.dates
+          
+          self.authors.each{ |a| el.add_element(a.to_xml('Author')) } if self.authors
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          author_ivorns = REXML::XPath.match(root, 'x:AuthorIVORN', {'x' => obj_ns.uri})
+          author_ivorns = nil if author_ivorns.size == 0
+          
+          dates = REXML::XPath.match(root, 'x:Date', {'x' => obj_ns.uri})
+          dates = nil if dates.size == 0
+          
+          authors = REXML::XPath.match(root, 'x:Author', {'x' => obj_ns.uri})
+          authors = nil if authors.size == 0
+          
+          self.new(
+            author_ivorns ? IVORNList.new(author_ivorns.collect{ |i| URI.parse(i.text) }) : nil,
+            dates ? DateTimeList.new(dates.collect{ |d| DateTime.parse(d.text) }) : nil,
+            authors ? AuthorList.new(authors.collect{ |a| Author.from_xml(a) }) : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+      class VOEvent < Described
+        attr_reader :who, :what, :where_when, :how, :why, :citations,
+          :version, :ivorn, :role
+          
+        def initialize(ivorn, who, what, where_when, how, why, version='1.1', role='observation', citations=nil, descriptions=nil, references=nil)
+          super(descriptions, references)
+          self.ivorn = ivorn
+          self.who = who
+          self.what = what
+          self.where_when = where_when
+          self.how = how
+          self.why = why
+          self.version = version || '1.1'
+          self.role = role || 'observation'
+          self.citations = citations
+        end
+        
+        def ivorn=(i)
+          raise_argument_required_error('IVORN') if !i
+          
+          i = URI.parse(i) if i.is_a?(String)
+          raise_type_mismatch_error(i, URI)
+          
+          @ivorn = i
+        end
+        
+        def who=(w)
+          raise_type_mismatch_error(w, Who) if w
+          @who = w
+        end
+        
+        def what=(w)
+          raise_type_mismatch_error(w, What) if w
+          @what = w
+        end
+        
+        def where_when=(ww)
+          raise_type_mismatch_error(ww, WhereWhen) if ww
+          @where_when = ww
+        end
+        
+        def how=(h)
+          raise_type_mismatch_error(h, How) if h
+          @how = h
+        end
+        
+        def why=(w)
+          raise_type_mismatch_error(w, Why) if w
+          @why = w
+        end
+        
+        def version=(v)
+          raise_argument_required_error('version') if !v
+          @version = v.to_s
+        end
+        
+        def role=(r)
+          @role = r ? r.to_s : nil
+        end
+        
+        def citations=(c)
+          raise_type_mismatch_error(c, Citations) if c
+          @citations = c
+        end
+        
+        def ==(e)
+          super(e) and
+          self.who == e.who and
+          self.what == e.what and
+          self.where_when == e.where_when and
+          self.how == e.how and
+          self.why == e.why and
+          self.citations == e.citations and
+          self.version == e.version and
+          self.ivorn == e.ivorn and
+          self.role == e.role
+        end
+        
+        def to_xml(name='VOEvent')
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:version"] = self.version
+          el.attributes["#{obj_ns.prefix}:ivorn"] = self.ivorn.to_s
+          el.attributes["#{obj_ns.prefix}:role"] = self.role if self.role
+          
+          el.add_element(self.who.to_xml('Who')) if self.who
+          el.add_element(self.what.to_xml('What')) if self.what
+          el.add_element(self.where_when.to_xml('WhereWhen')) if self.where_when
+          el.add_element(self.how.to_xml('How')) if self.how
+          el.add_element(self.why.to_xml('Why')) if self.why
+          el.add_element(self.citations.to_xml('Citations')) if self.citations
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          role = root.attributes.get_attribute_ns(obj_ns.uri, 'role')
+          
+          who = REXML::XPath.first(root, 'x:Who', {'x' => obj_ns.uri})
+          what = REXML::XPath.first(root, 'x:What', {'x' => obj_ns.uri})
+          where_when = REXML::XPath.first(root, 'x:WhereWhen', {'x' => obj_ns.uri})
+          how = REXML::XPath.first(root, 'x:How', {'x' => obj_ns.uri})
+          why = REXML::XPath.first(root, 'x:Why', {'x' => obj_ns.uri})
+          citations = REXML::XPath.first(root, 'x:Citations', {'x' => obj_ns.uri})
+          
+          self.new(
+            URI.parse(root.attributes.get_attribute_ns(obj_ns.uri, 'ivorn').value),
+            who ? Who.from_xml(who) : nil,
+            what ? What.from_xml(what) : nil,
+            where_when ? WhereWhen.from_xml(where_when) : nil,
+            how ? How.from_xml(how) : nil,
+            why ? Why.from_xml(why) : nil,
+            root.attributes.get_attribute_ns(obj_ns.uri, 'version').value,
+            role ? role.value : nil,
+            citations ? Citations.from_xml(citations) : nil,
+            *Described.described_from_xml(root)
+          )
+        end
+      end
+      
+    end
+  end
+end