rb_lovely 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a101665aa179ecfdd7edfce739f5f2feee1af73d
-  data.tar.gz: 819f929306b9aeef392d0325e311badac9e4c019
+  metadata.gz: cc6858428c1b20ccab46f7c4b561e3531853ad7a
+  data.tar.gz: 2de01f2967e14c0149184a12b7191969b07a0821
 SHA512:
-  metadata.gz: 26d39b7cee7223eb6e66cd5e7fecac58e59fcc3e9880e24c3c120e582ca590492d2f38fab8607ee03be02eca2747327841d6238cbda17db94cdd3f2aee0e035f
-  data.tar.gz: ba9d4986fce10cf32ea1c268cfa5e85301d28baa1d547646d1d9b4fe87167374d496e53ff806c43cd4c837a5d74f39319089872201f3396c6a63d4e9c3ea7636
+  metadata.gz: 23cdc3ee67aeab749cb6bc0dadb1864f4b860511d9ed511abcf7854c601f6858c34be1a8cb16b8e0f3e2ee4481dd6740188978fb1a9cf54744508bb8027b98b9
+  data.tar.gz: 1e7d603e62caa5c32773bdcda4366a928e3e16ab47fb3392a8173904daabb7a7407093c307db312578962ef51c9bde2da57b6b0fe1fc043e0323c9594096028c

data/.yardopts

@@ -0,0 +1 @@
+yard.rb

data/yard.rb

@@ -0,0 +1,197 @@
+# This file is used to build the yard documentation only as yard cannot currently
+# generate ruby documentation from C++ files.
+# The source code for this extension can be found in ext/rb_lovely.
+
+# Contains sorted container implementations.
+# @author nuisanceofcats
+module RbLovely
+
+  # Implement a sorted set with no duplicates where values are compared and sorted using the <=> operator on each member.
+  # @note
+  #   A SortedSet should not be modified during iteration.
+  #
+  #   Some methods come from the {http://www.ruby-doc.org/core-2.1.2/Enumerable.html Enumerable} module. If you do not find the method you are looking for in this documentation then please look there.
+  #
+  # @author nuisanceofcats
+  # @example
+  #   class Person < Struct.new(:name, :age)
+  #     def <=> other
+  #       return age - other.age
+  #     end
+  #   end
+  #
+  #   empty_set = RbLovely::SortedSet.new
+  #
+  #   set = RbLovely::SortedSet.new [ Person.new('Nyamuk', 2), Person.new('Cold Rain', 9999) ]
+  #   set.add Person.new('Beards', 15)
+  #   set << Person.new('Anna', 12)
+  #   set.add Person.new('Moust', 18)
+  #   expect(set.first.name).to equal 'Nyamuk'
+  #   expect(set.last.name).to equal 'Cold Rain'
+  #   expect(set.length).to equal 5
+  #
+  #   # Gond isn't added because <=> returns 0 for him and Anna
+  #   set.add Person.new('Gond', 12)
+  #   expect(set.length).to equal 5
+  class SortedSet
+    include Enumerable
+
+    # @param content [Array] An array of values to insert into the set.
+    def initialize content = [] ; end
+
+    # Deletes first member equivalent to value.
+    # @complexity O(log(n)).
+    # @return The value that was removed or nil if no value was removed.
+    # @param value Value to remove (each member is compared to value using the <=> method).
+    # @example
+    #   set = RbLovely::SortedSet.new [ 1, 5, 3 ]
+    #   set.delete 3
+    #   expect(set.to_a).to eql [1, 5]
+    def delete value ; end
+
+    # Access the first element in the set.
+    # @complexity O(c).
+    # @return The first value according to the <=> method defined on each member.
+    # @example
+    #   set = RbLovely::SortedSet.new [4, 0, 2]
+    #   expect(set.first).to equal 0
+    def first ; end
+
+    # Remove the first element from the set.
+    # @complexity O(c).
+    # @return The first value according to the <=> method defined on each member or nil if the set is empty.
+    # @example
+    #   set = RbLovely::SortedSet.new [4, 0, 2]
+    #   expect(set.shift).to equal 0
+    def shift ; end
+
+    # Access the last element in the set.
+    # @complexity O(c).
+    # @return The last value according to the <=> method defined on each member.
+    # @example
+    #   set = RbLovely::SortedSet.new [4, 0, 2]
+    #   expect(set.last).to equal 4
+    def last ; end
+
+    # Remove the last element from the set.
+    # @complexity O(c).
+    # @return The last value according to the <=> method defined on each member or nil if the set is empty.
+    # @example
+    #   set = RbLovely::SortedSet.new [4, 0, 2]
+    #   expect(set.pop).to equal 4
+    def pop ; end
+
+    # Remove elements from the set match a given predicate.
+    # @complexity O(n)
+    # @param predicate Items are removed from the set for which predicate returns true.
+    # @example
+    #   set = RbLovely::SortedSet.new [0, 1, 2, 3]
+    #   set.reject!(&:odd?)
+    #   expect(set.to_a).to eql([0, 2])
+    def reject!(&predicate) ; end
+
+    # Remove the first element from the set that matches the given predicate.
+    # @complexity O(log n)
+    # @param predicate The first item is removed which predicate returns true for.
+    # @example
+    #   set = RbLovely::SortedSet.new [0, 1, 2, 3]
+    #   set.reject!(&:odd?)
+    #   expect(set.to_a).to eql([0, 2, 3])
+    def reject_first!(&predicate) ; end
+
+    # Remove elements from the set that do not match a given predicate.
+    # @complexity O(n)
+    # @param predicate Items are removed from the set for which predicate does not return true.
+    # @example
+    #   set = RbLovely::SortedSet.new [0, 1, 2, 3]
+    #   set.select!(&:odd?)
+    #   expect(set.to_a).to eql([1, 3])
+    def select!(&predicate) ; end
+
+    # Calls block once with each value in the set.
+    # @complexity O(n)
+    # @example
+    #   set = RbLovely::SortedSet.new [0, 1, 2, 3]
+    #   set.each { |x| puts x }
+    def each(&block) ; end
+  end
+
+
+  # A SortedHash provides hashed unique keys and ordered non-unique values. Values are sorted using "<=>" and keys are tested for equality using "eql?".
+  # @note
+  #   A SortedHash should not be modified during iteration.
+  #
+  #   This class is only provided if boost is available on the system when the gem is installed as it is built using the {http://www.boost.org/doc/libs/1_56_0/libs/multi_index/doc/index.html Boost Multi-index Containers Library}.
+  #
+  #   Some methods come from the {http://www.ruby-doc.org/core-2.1.2/Enumerable.html Enumerable} module. If you do not find the method you are looking for in this documentation then please look there.
+  # @author nuisanceofcats
+  # @example
+  #   empty_hash = RbLovely::SortedHash.new
+  #
+  #   # constructor is like: hash[20] = 5 ; hash[9] = 1
+  #   hash = RbLovely::SortedHash.new [20, 5, 9, 1]
+  #   hash[2] = 16
+  #   hash[20] = 4 # updates previous value
+  #   expect(hash[20]).to equal 4
+  #   expect(hash.length).to equal 3
+  class SortedHash
+    include Enumerable
+
+    # @param content [Array] An array containing key, value, key, value ...
+    # @param compare [Proc] Comparison function used to order values (rather than default
+    #                       of using <=> method).
+    # @example
+    #   hash = RbLovely::SortedHash.new([:a, 10, :c, 5, :b, 1 ])
+    #   expect(hash.to_a).to eql [[:b, 1], [:c, 5], [:a, 10]]
+    #
+    #   # compare function reverses default sort order
+    #   hash = RbLovely::SortedHash.new(compare: proc { |a, b| b <=> a })
+    #   hash[:a] = 1
+    #   hash[:c] = 5
+    #   hash[:b] = 10
+    #   expect(hash.to_a).to eql [[:b, 10], [:c, 5], [:a, 1 ]]
+    def initialize content = [], compare: nil ; end
+
+    # Delete the value associated with a key.
+    # @return The value associated with the deleted key or nil if the key was not in the hash.
+    # @example
+    #   hash = RbLovely::SortedHash.new([:a, 5 ])
+    #   expect(hash.delete(:a)).to equal 5
+    #   expect(hash.delete(:b)).to equal nil
+    def delete key ; end
+
+    # Calls block once for each key, passing the key-value pair as parameters.
+    # @complexity O(n)
+    # @example
+    #   hash = RbLovely::SortedHash.new [:a, 10, :b, 1]
+    #   # This would call the block in value order: with (:b, 1) followed by (:a, 10).
+    #   hash.each { |key, value| puts "#{key} => #{value}" }
+    def each(&block) ; end
+
+    # Remove all values from the hash.
+    # @example
+    #   hash = RbLovely::SortedHash.new [:a, 10]
+    #   hash.clear
+    #   expect(hash.length).to equal 0
+    def clear ; end
+
+    # Retrieve value associated with the corresponding key or nil if the key doesn't exist.
+    # @complexity O(c)
+    # @example
+    #   hash = RbLovely::SortedHash.new [:a, 2]
+    #   expect(hash[:a]).to equal 2
+    #   expect(hash[:b]).to equal nil
+    def [](key) ; end
+
+    # Return true if the key is contained in the hash.
+    def include?(key) ; end
+
+    # Retrieve first value sorted by <=> or comparison function or nil if the hash is empty.
+    def first ; end
+
+    # Retrieve last value sorted by <=> or comparison function or nil if the hash is empty.
+    def last ; end
+
+    alias :has_key? :include?
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_lovely
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - James Pike
@@ -19,12 +19,14 @@ extensions:
 - ext/rb_lovely/extconf.rb
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - ext/rb_lovely/container.hpp
 - ext/rb_lovely/extconf.rb
 - ext/rb_lovely/package.cpp
 - ext/rb_lovely/ruby_util.hpp
 - ext/rb_lovely/sorted_hash.cpp
 - ext/rb_lovely/sorted_set.cpp
+- yard.rb
 homepage: https://github.com/nuisanceofcats/rb_lovely
 licenses:
 - Expat