xml-mapping 0.8

data/lib/xml/mapping/standard_nodes.rb

@@ -0,0 +1,343 @@
+# xml-mapping -- bidirectional Ruby-XML mapper
+#  Copyright (C) 2004,2005 Olaf Klischat
+
+module XML
+
+  module Mapping
+
+    # Node factory function synopsis:
+    # 
+    #   text_node :_attrname_, _path_ [, :default_value=>_obj_]
+    #                                 [, :optional=>true]
+    #
+    # Node that maps an XML node's text (the element's first child
+    # text node resp. the attribute's value) to a (string) attribute
+    # of the mapped object. Since TextNode inherits from
+    # SingleAttributeNode, the first argument to the node factory
+    # function is the attribute name (as a symbol). Handling of
+    # <tt>:default_value</tt> and <tt>:optional</tt> option arguments
+    # (if given) is also provided by the superclass -- see there for
+    # details.
+    class TextNode < SingleAttributeNode
+      # Initializer. _path_ (a string, the 2nd argument to the node
+      # factory function) is the XPath expression that locates the
+      # mapped node in the XML.
+      def initialize_impl(path)
+        @path = XML::XXPath.new(path)
+      end
+      def extract_attr_value(xml) # :nodoc:
+        default_when_xpath_err{ @path.first(xml).text }
+      end
+      def set_attr_value(xml, value) # :nodoc:
+        @path.first(xml,:ensure_created=>true).text = value
+      end
+    end
+
+    # Node factory function synopsis:
+    # 
+    #   numeric_node :_attrname_, _path_ [, :default_value=>_obj_]
+    #                                    [, :optional=>true]
+    #
+    # Like TextNode, but interprets the XML node's text as a number
+    # (Integer or Float, depending on the nodes's text) and maps it to
+    # an Integer or Float attribute.
+    class NumericNode < SingleAttributeNode
+      def initialize_impl(path)
+        @path = XML::XXPath.new(path)
+      end
+      def extract_attr_value(xml) # :nodoc:
+        txt = default_when_xpath_err{ @path.first(xml).text }
+        begin
+          Integer(txt)
+        rescue ArgumentError
+          Float(txt)
+        end
+      end
+      def set_attr_value(xml, value) # :nodoc:
+        raise RuntimeError, "Not an integer: #{value}" unless Numeric===value
+        @path.first(xml,:ensure_created=>true).text = value.to_s
+      end
+    end
+
+    # (does somebody have a better name for this class?) base node
+    # class that provides an initializer which lets the user specify a
+    # means to marshal/unmarshal a Ruby object to/from XML. Used as
+    # the base class for nodes that map some sub-nodes of their XML
+    # tree to (Ruby-)sub-objects of their attribute.
+    class SubObjectBaseNode < SingleAttributeNode
+      # processes the keyword arguments :class, :marshaller, and
+      # :unmarshaller (_args_ is ignored). When this initiaizer
+      # returns, @options[:marshaller] and @options[:unmarshaller] are
+      # set to procs that marshal/unmarshal a Ruby object to/from an
+      # XML tree according to the keyword arguments that were passed
+      # to the initializer:
+      #
+      # You either supply a :class argument with a class implementing
+      # XML::Mapping -- in that case, the subtree will be mapped to an
+      # instance of that class (using load_from_xml
+      # resp. fill_into_xml). Or, you supply :marshaller and
+      # :unmarshaller arguments specifying explicit
+      # unmarshaller/marshaller procs. The :marshaller proc takes
+      # arguments _xml_,_value_ and must fill _value_ (the object to
+      # be marshalled) into _xml_; the :unmarshaller proc takes _xml_
+      # and must extract and return the object value from it. Or, you
+      # specify none of those arguments, in which case the name of the
+      # class to create will be automatically deduced from the root
+      # element name of the XML node (see
+      # XML::Mapping::load_object_from_xml,
+      # XML::Mapping::class_for_root_elt_name).
+      #
+      # If both :class and :marshaller/:unmarshaller arguments are
+      # supplied, the latter take precedence.
+      def initialize_impl(*args)
+        if @options[:class]
+          unless @options[:marshaller]
+            @options[:marshaller] = proc {|xml,value|
+              value.fill_into_xml(xml)
+            }
+          end
+          unless @options[:unmarshaller]
+            @options[:unmarshaller] = proc {|xml|
+              @options[:class].load_from_xml(xml)
+            }
+          end
+        end
+
+        unless @options[:marshaller]
+          @options[:marshaller] = proc {|xml,value|
+            value.fill_into_xml(xml)
+            if xml.unspecified?
+              xml.name = value.class.root_element_name
+              xml.unspecified = false
+            end
+          }
+        end
+        unless @options[:unmarshaller]
+          @options[:unmarshaller] = proc {|xml|
+            XML::Mapping.load_object_from_xml(xml)
+          }
+        end
+      end
+    end
+
+    # Node factory function synopsis:
+    # 
+    #   object_node :_attrname_, _path_ [, :default_value=>_obj_]
+    #                                   [, :optional=>true]
+    #                                   [, :class=>_c_]
+    #                                   [, :marshaller=>_proc_]
+    #                                   [, :unmarshaller=>_proc_]
+    #
+    # Node that maps a subtree in the source XML to a Ruby
+    # object. :_attrname_ and _path_ are again the attribute name
+    # resp. XPath expression of the mapped attribute; the keyword
+    # arguments <tt>:default_value</tt> and <tt>:optional</tt> are
+    # handled by the SingleAttributeNode superclass. The XML subnode
+    # named by _path_ is mapped to the attribute named by :_attrname_
+    # according to the keyword arguments <tt>:class</tt>,
+    # <tt>:marshaller</tt>, and <tt>:unmarshaller</tt>, which are
+    # handled by the SubObjectBaseNode superclass.
+    class ObjectNode < SubObjectBaseNode
+      # Initializer. _path_ (a string denoting an XPath expression) is
+      # the location of the subtree.
+      def initialize_impl(path)
+        super
+	@path = XML::XXPath.new(path)
+      end
+      def extract_attr_value(xml) # :nodoc:
+        @options[:unmarshaller].call(default_when_xpath_err{@path.first(xml)})
+      end
+      def set_attr_value(xml, value) # :nodoc:
+        @options[:marshaller].call(@path.first(xml,:ensure_created=>true), value)
+      end
+    end
+
+    # Node factory function synopsis:
+    # 
+    #   boolean_node :_attrname_, _path_,
+    #                _true_value_, _false_value_ [, :default_value=>_obj_]
+    #                                            [, :optional=>true]
+    #
+    # Node that maps an XML node's text (the element name resp. the
+    # attribute value) to a boolean attribute of the mapped
+    # object. The attribute named by :_attrname_ is mapped to/from the
+    # XML subnode named by the XPath expression _path_. _true_value_
+    # is the text the node must have in order to represent the +true+
+    # boolean value, _false_value_ (actually, any value other than
+    # _true_value_) is the text the node must have in order to
+    # represent the +false+ boolean value.
+    class BooleanNode < SingleAttributeNode
+      # Initializer.
+      def initialize_impl(path,true_value,false_value)
+        @path = XML::XXPath.new(path)
+        @true_value = true_value; @false_value = false_value
+      end
+      def extract_attr_value(xml) # :nodoc:
+        default_when_xpath_err{ @path.first(xml).text==@true_value }
+      end
+      def set_attr_value(xml, value) # :nodoc:
+        @path.first(xml,:ensure_created=>true).text = value ? @true_value : @false_value
+      end
+    end
+
+    # Node factory function synopsis:
+    # 
+    #   array_node :_attrname_, _per_arrelement_path_
+    #                     [, :default_value=>_obj_]
+    #                     [, :optional=>true]
+    #                     [, :class=>_c_]
+    #                     [, :marshaller=>_proc_]
+    #                     [, :unmarshaller=>_proc_]
+    #
+    # -or-
+    #
+    #   array_node :_attrname_, _base_path_, _per_arrelement_path_
+    #                     [keyword args the same]
+    #
+    # Node that maps a sequence of sub-nodes of the XML tree to an
+    # attribute containing an array of Ruby objects, with each array
+    # element mapping to a corresponding member of the sequence of
+    # sub-nodes.
+    #
+    # If _base_path_ is not supplied, it is assumed to be
+    # "". _base_path_+<tt>"/"</tt>+_per_arrelement_path_ is an XPath
+    # expression that must "yield" the sequence of XML nodes that is
+    # to be mapped to the array.  The difference between _base_path_
+    # and _per_arrelement_path_ becomes important when marshalling the
+    # array attribute back to XML. When that happens, _base_path_
+    # names the most specific common parent node of all the mapped
+    # sub-nodes, and _per_arrelement_path_ names (relative to
+    # _base_path_) the part of the path that is duplicated for each
+    # array element. For example, with _base_path_==<tt>"foo/bar"</tt>
+    # and _per_arrelement_path_==<tt>"hi/ho"</tt>, an array
+    # <tt>[x,y,z]</tt> will be written to an XML structure that looks
+    # like this:
+    #
+    #   <foo>
+    #    <bar>
+    #     <hi>
+    #      <ho>
+    #       [marshalled object x]
+    #      </ho>
+    #     </hi>
+    #     <hi>
+    #      <ho>
+    #       [marshalled object y]
+    #      </ho>
+    #     </hi>
+    #     <hi>
+    #      <ho>
+    #       [marshalled object z]
+    #      </ho>
+    #     </hi>
+    #    </bar>
+    #   </foo>
+    class ArrayNode < SubObjectBaseNode
+      # Initializer, delegates to do_initialize. Called with keyword
+      # arguments and either 1 or 2 paths; the hindmost path argument
+      # passed is delegated to _per_arrelement_path_; the preceding
+      # path argument (if present, "" by default) is delegated to
+      # _base_path_.
+      def initialize_impl(path,path2=nil)
+        super
+	if path2
+	  do_initialize(path,path2)
+	else
+	  do_initialize("",path)
+	end
+      end
+      # "Real" initializer.
+      def do_initialize(base_path,per_arrelement_path)
+	per_arrelement_path=per_arrelement_path[1..-1] if per_arrelement_path[0]==?/
+	@base_path = XML::XXPath.new(base_path)
+	@per_arrelement_path = XML::XXPath.new(per_arrelement_path)
+	@reader_path = XML::XXPath.new(base_path+"/"+per_arrelement_path)
+      end
+      def extract_attr_value(xml) # :nodoc:
+        result = []
+        default_when_xpath_err{@reader_path.all(xml)}.each do |elt|
+          result << @options[:unmarshaller].call(elt)
+        end
+        result
+      end
+      def set_attr_value(xml, value) # :nodoc:
+	base_elt = @base_path.first(xml,:ensure_created=>true)
+	value.each do |arr_elt|
+          @options[:marshaller].call(@per_arrelement_path.create_new(base_elt), arr_elt)
+	end
+      end
+    end
+
+
+    # Node factory function synopsis:
+    # 
+    #   hash_node :_attrname_, _per_hashelement_path_, _key_path_
+    #                     [, :default_value=>_obj_]
+    #                     [, :optional=>true]
+    #                     [, :class=>_c_]
+    #                     [, :marshaller=>_proc_]
+    #                     [, :unmarshaller=>_proc_]
+    #
+    # - or -
+    #
+    #   hash_node :_attrname_, _base_path_, _per_hashelement_path_, _key_path_
+    #                     [keyword args the same]
+    #
+    # Node that maps a sequence of sub-nodes of the XML tree to an
+    # attribute containing a hash of Ruby objects, with each hash
+    # value mapping to a corresponding member of the sequence of
+    # sub-nodes. The (string-valued) hash key associated with a hash
+    # value _v_ is mapped to the text of a specific sub-node of _v_'s
+    # sub-node.
+    #
+    # Analogously to ArrayNode, _base_path_ and _per_arrelement_path_
+    # define the XPath expression that "yields" the sequence of XML
+    # nodes, each of which maps to a value in the hash table. Relative
+    # to such a node, key_path_ names the node whose text becomes the
+    # associated hash key.
+    class HashNode < SubObjectBaseNode
+      # Initializer, delegates to do_initialize. Called with keyword
+      # arguments and either 2 or 3 paths; the hindmost path argument
+      # passed is delegated to _key_path_, the preceding path argument
+      # is delegated to _per_arrelement_path_, the path preceding that
+      # argument (if present, "" by default) is delegated to
+      # _base_path_. The meaning of the keyword arguments is the same
+      # as for ObjectNode.
+      def initialize_impl(path1,path2,path3=nil)
+        super
+        if path3
+          do_initialize(path1,path2,path3)
+        else
+          do_initialize("",path1,path2)
+        end
+      end
+      # "Real" initializer.
+      def do_initialize(base_path,per_hashelement_path,key_path)
+	per_hashelement_path=per_hashelement_path[1..-1] if per_hashelement_path[0]==?/
+	@base_path = XML::XXPath.new(base_path)
+	@per_hashelement_path = XML::XXPath.new(per_hashelement_path)
+	@key_path = XML::XXPath.new(key_path)
+	@reader_path = XML::XXPath.new(base_path+"/"+per_hashelement_path)
+      end
+      def extract_attr_value(xml) # :nodoc:
+        result = {}
+        default_when_xpath_err{@reader_path.all(xml)}.each do |elt|
+          key = @key_path.first(elt).text
+          value = @options[:unmarshaller].call(elt)
+          result[key] = value
+        end
+        result
+      end
+      def set_attr_value(xml, value) # :nodoc:
+	base_elt = @base_path.first(xml,:ensure_created=>true)
+	value.each_pair do |k,v|
+          elt = @per_hashelement_path.create_new(base_elt)
+          @options[:marshaller].call(elt,v)
+          @key_path.first(elt,:ensure_created=>true).text = k
+	end
+      end
+    end
+
+  end
+
+end

data/lib/xml/mapping/version.rb

@@ -0,0 +1,8 @@
+# xml-mapping -- bidirectional Ruby-XML mapper
+#  Copyright (C) 2004,2005 Olaf Klischat
+
+module XML
+  module Mapping
+    VERSION = '0.8'
+  end
+end

data/lib/xml/xxpath.rb

@@ -0,0 +1,354 @@
+# xpath.rb -- XPath implementation for Ruby, including write access
+#  Copyright (C) 2004,2005 Olaf Klischat
+
+require 'rexml/document'
+
+module XML
+
+  class XXPathError < RuntimeError
+  end
+
+  # Instances of this class hold (in a pre-compiled form) an XPath
+  # pattern. You call instance methods like +each+, +first+, +all+,
+  # <tt>create_new</tt> on instances of this class to apply the
+  # pattern to REXML elements.
+  class XXPath
+
+    # create and compile a new XPath. _xpathstr_ is the string
+    # representation (XPath pattern) of the path
+    def initialize(xpathstr)
+      @xpathstr = xpathstr  # for error messages
+
+      xpathstr=xpathstr[1..-1] if xpathstr[0]==?/
+
+      # TODO: avoid code duplications
+      #    maybe: build & create the procs using eval
+
+      @creator_procs = [ proc{|node,create_new| node} ]
+      @reader_proc = proc {|nodes| nodes}
+      xpathstr.split('/').reverse.each do |part|
+        prev_creator = @creator_procs[-1]
+        prev_reader = @reader_proc
+        case part
+        when /^(.*?)\[@(.*?)='(.*?)'\]$/
+          name,attr_name,attr_value = [$1,$2,$3]
+          @creator_procs << curr_creator = proc {|node,create_new|
+            prev_creator.call(Accessors.create_subnode_by_name_and_attr(node,create_new,
+                                                                        name,attr_name,attr_value),
+                              create_new)
+          }
+          @reader_proc = proc {|nodes|
+            next_nodes = Accessors.subnodes_by_name_and_attr(nodes,
+                                                             name,attr_name,attr_value)
+            if (next_nodes == [])
+              throw :not_found, [nodes,curr_creator]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        when /^(.*?)\[(.*?)\]$/
+          name,index = [$1,$2.to_i]
+          @creator_procs << curr_creator = proc {|node,create_new|
+            prev_creator.call(Accessors.create_subnode_by_name_and_index(node,create_new,
+                                                                         name,index),
+                              create_new)
+          }
+          @reader_proc = proc {|nodes|
+            next_nodes = Accessors.subnodes_by_name_and_index(nodes,
+                                                              name,index)
+            if (next_nodes == [])
+              throw :not_found, [nodes,curr_creator]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        when /^@(.*)$/
+          name = $1
+          @creator_procs << curr_creator = proc {|node,create_new|
+            prev_creator.call(Accessors.create_subnode_by_attr_name(node,create_new,name),
+                              create_new)
+          }
+          @reader_proc = proc {|nodes|
+            next_nodes = Accessors.subnodes_by_attr_name(nodes,name)
+            if (next_nodes == [])
+              throw :not_found, [nodes,curr_creator]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        when '*'
+          @creator_procs << curr_creator = proc {|node,create_new|
+            prev_creator.call(Accessors.create_subnode_by_all(node,create_new),
+                              create_new)
+          }
+          @reader_proc = proc {|nodes|
+            next_nodes = Accessors.subnodes_by_all(nodes)
+            if (next_nodes == [])
+              throw :not_found, [nodes,curr_creator]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        else
+          name = part
+          @creator_procs << curr_creator = proc {|node,create_new|
+            prev_creator.call(Accessors.create_subnode_by_name(node,create_new,name),
+                              create_new)
+          }
+          @reader_proc = proc {|nodes|
+            next_nodes = Accessors.subnodes_by_name(nodes,name)
+            if (next_nodes == [])
+              throw :not_found, [nodes,curr_creator]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        end
+      end
+    end
+
+
+    # loop over all sub-nodes of _node_ that match this XPath.
+    def each(node,options={},&block)
+      all(node,options).each(&block)
+    end
+
+    # the first sub-node of _node_ that matches this XPath. If nothing
+    # matches, raise XXPathError unless :allow_nil=>true was provided.
+    #
+    # If :ensure_created=>true is provided, first() ensures that a
+    # match exists in _node_, creating one if none existed before.
+    #
+    # <tt>path.first(node,:create_new=>true)</tt> is equivalent
+    # to <tt>path.create_new(node)</tt>.
+    def first(node,options={})
+      a=all(node,options)
+      if a.empty?
+        if options[:allow_nil]
+          nil
+        else
+          raise XXPathError, "path not found: #{@xpathstr}"
+        end
+      else
+        a[0]
+      end
+    end
+
+    # Return an Enumerable with all sub-nodes of _node_ that match
+    # this XPath. Returns an empty Enumerable if no match was found.
+    #
+    # If :ensure_created=>true is provided, all() ensures that a match
+    # exists in _node_, creating one (and returning it as the sole
+    # element of the returned enumerable) if none existed before.
+    def all(node,options={})
+      raise "options not a hash" unless Hash===options
+      if options[:create_new]
+        return [ @creator_procs[-1].call(node,true) ]
+      else
+        last_nodes,rest_creator = catch(:not_found) do
+          return @reader_proc.call([node])
+        end
+        if options[:ensure_created]
+          [ rest_creator.call(last_nodes[0],false) ]
+        else
+          []
+        end
+      end
+    end
+
+    # create a completely new match of this XPath in
+    # <i>base_node</i>. "Completely new" means that a new node will be
+    # created for each path element, even if a matching node already
+    # existed in <i>base_node</i>.
+    #
+    # <tt>path.create_new(node)</tt> is equivalent to
+    # <tt>path.first(node,:create_new=>true)</tt>.
+    def create_new(base_node)
+      first(base_node,:create_new=>true)
+    end
+
+
+    module Accessors  #:nodoc:
+
+      # we need a boolean "unspecified?" attribute for XML nodes --
+      # paths like "*" oder (somewhen) "foo|bar" create "unspecified"
+      # nodes that the user must then "specify" by setting their text
+      # etc. (or manually setting unspecified=false)
+      #
+      # This is mixed into the REXML::Element and
+      # XML::XXPath::Accessors::Attribute classes.
+      module UnspecifiednessSupport
+
+        def unspecified?
+          @xml_xpath_unspecified ||= false
+        end
+
+        def unspecified=(x)
+          @xml_xpath_unspecified = x
+        end
+
+        def self.included(mod)
+          mod.module_eval <<-EOS
+            alias_method :_text_orig, :text
+            alias_method :_textis_orig, :text=
+            def text
+              # we're suffering from the "fragile base class"
+              # phenomenon here -- we don't know whether the
+              # implementation of the class we get mixed into always
+              # calls text (instead of just accessing @text or so)
+              if unspecified?
+                "[UNSPECIFIED]"
+              else
+                _text_orig
+              end
+            end
+            def text=(x)
+              _textis_orig(x)
+              self.unspecified=false
+            end
+
+            alias_method :_nameis_orig, :name=
+            def name=(x)
+              _nameis_orig(x)
+              self.unspecified=false
+            end
+          EOS
+        end
+
+      end
+
+      class REXML::Element              #:nodoc:
+        include UnspecifiednessSupport
+      end
+
+      # attribute node, half-way compatible
+      # with REXML's Element.
+      # REXML doesn't provide one...
+      #
+      # The all/first calls return instances of this class if they
+      # matched an attribute node.
+      class Attribute
+        attr_reader :parent, :name
+        attr_writer :name
+
+        def initialize(parent,name)
+          @parent,@name = parent,name
+        end
+
+        def self.new(parent,name,create)
+          if parent.attributes[name]
+            super(parent,name)
+          else
+            if create
+              parent.attributes[name] = "[unset]"
+              super(parent,name)
+            else
+              nil
+            end
+          end
+        end
+
+        # the value of the attribute.
+        def text
+          parent.attributes[@name]
+        end
+
+        def text=(x)
+          parent.attributes[@name] = x
+        end
+
+        def ==(other)
+          other.kind_of?(Attribute) and other.parent==parent and other.name==name
+        end
+
+        include UnspecifiednessSupport
+      end
+
+      # read accessors
+
+      for things in %w{name name_and_attr name_and_index attr_name all} do
+        self.module_eval <<-EOS
+          def self.subnodes_by_#{things}(nodes, *args)
+            nodes.map{|node| subnodes_by_#{things}_singlesrc(node,*args)}.flatten
+          end
+        EOS
+      end
+
+      def self.subnodes_by_name_singlesrc(node,name)
+        node.elements.select{|elt| elt.name==name}
+      end
+
+      def self.subnodes_by_name_and_attr_singlesrc(node,name,attr_name,attr_value)
+        node.elements.select{|elt| elt.name==name and elt.attributes[attr_name]==attr_value}
+      end
+
+      def self.subnodes_by_name_and_index_singlesrc(node,name,index)
+        index-=1
+        byname=subnodes_by_name_singlesrc(node,name)
+        if index>=byname.size
+          []
+        else
+          [byname[index]]
+        end
+      end
+
+      def self.subnodes_by_attr_name_singlesrc(node,name)
+        attr=Attribute.new(node,name,false)
+        if attr then [attr] else [] end
+      end
+
+      def self.subnodes_by_all_singlesrc(node)
+        node.elements.to_a
+      end
+
+
+      # write accessors
+
+      #  precondition: unless create_new, we know that a node with
+      #    exactly the requested attributes doesn't exist yet (else we
+      #    wouldn't have been called)
+      def self.create_subnode_by_name(node,create_new,name)
+        node.elements.add name
+      end
+
+      def self.create_subnode_by_name_and_attr(node,create_new,name,attr_name,attr_value)
+        if create_new
+          newnode = node.elements.add(name)
+        else
+          newnode = subnodes_by_name_singlesrc(node,name)[0]
+          if not(newnode) or newnode.attributes[attr_name]
+            newnode = node.elements.add(name)
+          end
+        end
+        newnode.attributes[attr_name]=attr_value
+        newnode
+      end
+
+      def self.create_subnode_by_name_and_index(node,create_new,name,index)
+        name_matches = subnodes_by_name_singlesrc(node,name)
+        if create_new and (name_matches.size >= index)
+          raise XXPathError, "XPath (#{@xpathstr}): #{name}[#{index}]: create_new and element already exists"
+        end
+        newnode = name_matches[0]
+        (index-name_matches.size).times do
+          newnode = node.elements.add name
+        end
+        newnode
+      end
+
+      def self.create_subnode_by_attr_name(node,create_new,name)
+        if create_new and node.attributes[name]
+          raise XXPathError, "XPath (#{@xpathstr}): @#{name}: create_new and attribute already exists"
+        end
+        Attribute.new(node,name,true)
+      end
+
+      def self.create_subnode_by_all(node,create_new)
+        node = node.elements.add
+        node.unspecified = true
+        node
+      end
+    end
+  end
+
+end