# File lib/atom/element.rb, line 304
    def atom_attrb(name)
      self.attrb(['atom', Atom::NS], name)
    end

# File lib/atom/element.rb, line 217
    def atom_element(name, klass)
      self.element(['atom', Atom::NS], name, klass)
    end

# File lib/atom/element.rb, line 277
    def atom_elements(one_name, many_name, klass)
      self.elements(['atom', Atom::NS], one_name, many_name, klass)
    end

# File lib/atom/element.rb, line 309
    def atom_link name, criteria
      def_get name do
        existing = find_link(criteria)

        existing and existing.href
      end

      def_set name do |value|
        existing = find_link(criteria)

        if existing
          existing.href = value
        else
          links.new criteria.merge(:href => value)
        end
      end
    end

# File lib/atom/element.rb, line 159
    def atom_string(name)
      attr_accessor name

      self.parse_plain(Atom::NS, name)
      self.build_plain(['atom', Atom::NS], name)
    end

# File lib/atom/element.rb, line 189
    def  atom_timeatom_time(name)
      self.time ['atom', Atom::NS], name
    end

# File lib/atom/element.rb, line 282
    def attrb(ns, name)
      attr_accessor name

      self.on_parse_attr [ns[1], name] do |e,x|
        e.set(name, x)
      end

      self.on_build do |e,x|
        if v = e.get(name)
          n = name.to_s

          if x.namespace != ns[1]
            x.add_namespace *ns unless x.namespaces[ns[0]]
            n = "#{ns[0]}:#{n}"
          end

          x.attributes[n] = v.to_s
        end
      end
    end

# File lib/atom/element.rb, line 149
    def build_plain ns, name
      self.on_build do |e,x|
        if v = e.get(name)
          el = e.append_elem(x, ns, name)
          el.text = v.to_s
        end
      end
    end

# File lib/atom/element.rb, line 194
    def element(ns, name, klass)
      el_name = name
      name = name.to_s.gsub(/-/, '_')

      attr_reader name

      self.on_parse [ns[1], el_name] do |e,x|
        e.instance_variable_set("@#{name}", klass.parse(x, e.base))
      end

      self.on_build do |e,x|
        if v = e.get(name)
          el = e.append_elem(x, ns, el_name)
          v.build(el)
        end
      end

      def_set name do |value|
        instance_variable_set("@#{name}", klass.new(value))
      end
    end

# File lib/atom/element.rb, line 252
    def elements(ns, one_name, many_name, klass)
      attr_reader many_name

      self.on_init do
        var = Atom::Multiple(klass).new
        instance_variable_set("@#{many_name}", var)
      end

      self.on_parse_many [ns[1], one_name] do |e,xs|
        var = e.get(many_name)

        xs.each do |el|
          var << klass.parse(el, e.base)
        end
      end

      self.on_build do |e,x|
        e.get(many_name).each do |v|
          el = e.append_elem(x, ns, one_name)
          v.build(el)
        end
      end
    end

# File lib/atom/element.rb, line 225
    def strings(ns, one_name, many_name)
      attr_reader many_name

      self.on_init do
        instance_variable_set("@#{many_name}", [])
      end

      self.on_parse_many [ns[1], one_name] do |e,xs|
        var = e.instance_variable_get("@#{many_name}")

        xs.each do |el|
          var << el.text
        end
      end

      self.on_build do |e,x|
        e.instance_variable_get("@#{many_name}").each do |v|
          e.append_elem(x, ns, one_name).text = v
        end
      end
    end

# File lib/atom/element.rb, line 167
    def time(ns, name)
      attr_reader name

      self.def_set name do |time|
        unless time.respond_to? :iso8601
          time = Time.parse(time.to_s)
        end

        def time.to_s; iso8601; end

        instance_variable_set("@#{name}", time)
      end

      define_method "#{name}!".to_sym do
        set(name, Time.now)
      end

      self.parse_plain(ns[1], name)
      self.build_plain(ns, name)
    end