ruby​​的多索引容器

Question

有什么像boost :: multi_index但是对于ruby。基本上采取一些容器的对象，并使用N种不同的查询方法对N个不同的方式编制索引。

我想你可以在内存数据库中使用SQLite的DataMapper，但我想知道是否有任何纯粹的红宝石。

下面是这种类型可能做的一个想象的例子。它看起来非常像数据库，非常类似于 。

class Foo 
    attr_accessor :a 
    attr_accessor :b 
    attr_accessor :c 
end 


class FooIndexer < MultiIndex 
    hash_index :a do |o| 
     o.a 
    end 

    ordered_index :b do |x, y| 
     x.b <=> y.b 
    end 
end 


index = FooIndexer.new 

index.insert(Foo.new (...)) 
index.insert(Foo.new (...)) 
index.insert(Foo.new (...)) 
index.insert(Foo.new (...)) 
index.insert(Foo.new (...)) 


index.find (index.a == 10) 
index.find (index.b > 10 ) 

Answer 1

这听起来像是你在实现此功能的特定方式之后。但是就红宝石般的接口而言，我会推荐使用Enumerable#find方法。这样，你可以说

foo_container = [FooIndexer.new, ...] 
foo_container.find{|x| x.a == 10} 

它看起来非常像你的例子，除了括号而不是括号！

后来，如果您发现性能很差，您可能想要进行某种缓存或优化find。但是，仅根据您的问题，如果您现在查找该问题，您将尽快进行优化。

Enumerable提供了大量的这些事情了，所以你有一个像

foo_container.select{|x| x.a == 10} # Finds all instances. 
foo_container.reject{|x| x.a == 10} # Finds the complementary set. 

Answer 2

这是一个完全的工作方案，包括规范，但仅适用于 多个哈希键自然延伸。

require 'pp' 

class MKey 
    def initialize &bk 
    @block = bk 
    @containers = {} 
    end 

    def <<(val) 
    keys = @block.call(val) 
    keys.each do |k,v| 
     @containers[k] ||= {} 
     @containers[k][v] = val 
    end 
    end 

    def [](key) 
    k, v = key.first 
    @containers[k][v] 
    end 

    def delete(key) 
    val = self[key] 
    keys = @block.call(val) 
    keys.each do |k,v| 
     @containers[k].delete(v) 
    end 
    end 

    include Enumerable 

    def each 
    k, c = @containers.first 
    c.each do |k, val| 
     yield val 
    end 
    end 

end 


describe MKey do 

    class Foo 
    def initialize(a,b) 
     @a = a 
     @b = b 
    end 
    attr_accessor :a 
    attr_accessor :b 
    end 

    it "should insert" do 

    index = MKey.new do |o| 
     { :a => o.a, 
     :b => o.b 
     } 
    end 

    x = Foo.new("hello", "cat") 
    y = Foo.new("goodbye", "code") 

    index << x 
    index << y 

    # Test Enumerable interface 
    index.find do |val| 
     val.a == "hello" 
    end.should == x 

    # Test multi key interface 
    index[:a => "hello"].should == x 
    index[:b => "code"].should == y 

    index.delete(:a => "hello") 

    index[:a => "hello"].should == nil 
    index[:b => "code"].should == y 

    index.delete(:b => "code") 

    index[:a => "hello"].should == nil 
    index[:b => "code"].should == nil 


    end 

    it "hash lookup should be faster than find" do 


    index = MKey.new do |o| 
     { :a => o.a, 
     :b => o.b 
     } 
    end 

    for i in 1..10000 
     index << Foo.new(i, i*100) 
    end 

    t0 = timer do 
     index[:a => 1000] 
    end 

    t1 = timer do 
     index.find {|v| v.a == 10000} 
    end 

    t0.should < t1 * 100 

    end 

end