File: namedelements.rb

package info (click to toggle)
ruby-soap4r 2.0.5-9
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 5,032 kB
  • sloc: ruby: 52,729; xml: 266; sh: 42; javascript: 20; makefile: 13; perl: 10
file content (132 lines) | stat: -rw-r--r-- 1,964 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
# XSD4R - WSDL named element collection.
# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.

# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
# redistribute it and/or modify it under the same terms of Ruby's license;
# either the dual license version in 2003, or any later version.


module XSD


class NamedElements
  include Enumerable

  def initialize
    @elements = []
    @cache = {}
  end

  def dup
    o = NamedElements.new
    o.elements = @elements.dup
    o
  end

  def freeze
    super
    @elements.freeze
    self
  end

  def empty?
    size == 0
  end

  def size
    @elements.size
  end

  def [](idx)
    if idx.is_a?(Numeric)
      @elements[idx]
    else
      @cache[idx] ||= @elements.find { |item| item.name == idx }
    end
  end

  def find_name(name)
    @elements.find { |item| item.name.name == name }
  end

  def keys
    collect { |element| element.name }
  end

  def each
    @elements.each do |element|
      yield(element)
    end
  end

  def <<(rhs)
    @elements << rhs
    self
  end
  
  def delete(rhs)
    rv = @elements.delete(rhs)
    @cache.clear
    rv
  end

  def +(rhs)
    o = NamedElements.new
    o.elements = @elements + rhs.elements
    @cache.clear
    o
  end

  def concat(rhs)
    @elements.concat(rhs.elements)
    @cache.clear
    self
  end

  def uniq
    o = NamedElements.new
    o.elements = uniq_elements
    o
  end

  def uniq!
    @elements.replace(uniq_elements)
    @cache.clear
  end

  def find_all
    o = NamedElements.new
    each do |ele|
      o << ele if yield(ele)
    end
    o
  end

  Empty = NamedElements.new.freeze

protected

  def elements=(rhs)
    @elements = rhs
  end

  def elements
    @elements
  end

private

  def uniq_elements
    dict = {}
    elements = []
    @elements.each do |ele|
      unless dict.key?(ele.name)
        dict[ele.name] = ele
        elements << ele
      end
    end
    elements
  end
end

end