class IDRegistry::Registry

# File lib/idregistry/registry.rb, line 260
def add(type_, object_)
  @config.lock

  # Some sanity checks of the arguments.
  if object_.nil?
    raise ObjectKeyError, "Attempt to add a nil object"
  end
  unless @types.has_key?(type_)
    raise ObjectKeyError, "Unrecognized type: #{type_}"
  end

  # Synchronize the actual add to protect against concurrent mutation.
  @mutex.synchronize do
    _internal_add(type_, object_, nil, nil)
  end
  self
end

# File lib/idregistry/registry.rb, line 150
def categories(arg_)
  @config.lock

  objdata_ = _get_objdata(arg_)
  return nil unless objdata_
  hash_ = {}
  objdata_[2].each do |tup_, tupcats_|
    tupcats_.each do |cat_|
      hash_[cat_] = @categories[cat_][1].map{ |elem_| tup_[elem_] }
    end
  end
  hash_
end

# File lib/idregistry/registry.rb, line 389
def clear
  @mutex.synchronize do
    @tuples.clear
    @objects.clear
    @catdata.clear
  end
  self
end

# File lib/idregistry/registry.rb, line 68
def config(&block_)
  ::Blockenspiel.invoke(block_, @config) if block_
  @config
end

# File lib/idregistry/registry.rb, line 288
def delete(arg_)
  @config.lock

  @mutex.synchronize do
    if (objdata_ = _get_objdata(arg_))
      @objects.delete(objdata_[0].object_id)
      objdata_[2].each_key{ |tup_| _remove_tuple(objdata_, tup_) }
    end
  end
  self
end

# File lib/idregistry/registry.rb, line 305
def delete_category(category_type_, *category_spec_)
  @config.lock

  if @categories.include?(category_type_)
    spec_ = category_spec_.size == 1 && category_spec_.first.is_a?(::Array) ? category_spec_.first : category_spec_
    if (tuple_hash_ = (@catdata[category_type_] ||= {})[spec_])
      @mutex.synchronize do
        tuple_hash_.values.each do |objdata_|
          @objects.delete(objdata_[0].object_id)
          objdata_[2].each_key{ |tup_| _remove_tuple(objdata_, tup_) }
        end
      end
    end
  end
  self
end

# File lib/idregistry/registry.rb, line 100
def get(tuple_)
  objdata_ = @tuples[tuple_]
  objdata_ ? objdata_[0] : nil
end

# File lib/idregistry/registry.rb, line 132
def include?(arg_)
  _get_objdata(arg_) ? true : false
end

# File lib/idregistry/registry.rb, line 204
def lookup(*args_)
  opts_ = args_.last.is_a?(::Hash) ? args_.pop : {}
  tuple_ = args_.size == 1 && args_.first.is_a?(::Array) ? args_.first : args_

  @config.lock

  # Fast-track lookup if it's already there
  if (objdata_ = @tuples[tuple_])
    return objdata_[0]
  end

  # Not there for now. Try to create the object.
  # We want to do this before entering the synchronize block because
  # we don't want callbacks called within the synchronization.
  obj_ = nil
  type_ = nil
  pattern_ = nil
  @patterns.each do |pat_, patdata_|
    if Utils.matches?(pat_, tuple_)
      block_ = patdata_[1]
      obj_ = case block_.arity
        when 0 then block_.call
        when 1 then block_.call(tuple_)
        when 2 then block_.call(tuple_, self)
        else block_.call(tuple_, self, opts_)
      end
      unless obj_.nil?
        pattern_ = pat_
        type_ = patdata_[0]
        break
      end
    end
  end

  if obj_
    # Now attempt to insert the object.
    # This part is synchronized to protect against concurrent mutation.
    # Once in the synchronize block, we also double-check that no other
    # thread added the object in the meantime. If another thread did,
    # we throw away the object we just created, and return the other
    # thread's object instead.
    @mutex.synchronize do
      if (objdata_ = @tuples[tuple_])
        obj_ = objdata_[0]
      else
        _internal_add(type_, obj_, tuple_, pattern_)
      end
    end
  end
  obj_
end

# File lib/idregistry/registry.rb, line 169
def objects_in_category(category_type_, *category_spec_)
  @config.lock

  return nil unless @categories.include?(category_type_)
  spec_ = category_spec_.size == 1 && category_spec_.first.is_a?(::Array) ? category_spec_.first : category_spec_
  tuple_hash_ = (@catdata[category_type_] ||= {})[spec_]
  tuple_hash_ ? tuple_hash_.values.map{ |objdata_| objdata_[0] } : []
end

# File lib/idregistry/registry.rb, line 334
def rekey(arg_)
  @config.lock

  # Resolve the object.
  if (objdata_ = _get_objdata(arg_))

    # Look up tuple generators from the type, and determine the
    # new tuples for the object.
    # Do this before entering the synchronize block because we
    # don't want callbacks called within the synchronization.
    obj_ = objdata_[0]
    type_ = objdata_[1]
    new_tuple_list_ = []
    @types[type_].each do |pat_|
      if (block_ = @patterns[pat_][2])
        new_tuple_ = block_.call(obj_)
        new_tuple_list_ << new_tuple_ if new_tuple_
      else
        raise ObjectKeyError, "Not all patterns for this type can generate tuples"
      end
    end

    # Synchronize to protect against concurrent mutation.
    @mutex.synchronize do
      # One last check to ensure the object is still present
      if @objects.has_key?(obj_.object_id)
        # Ensure none of the new tuples isn't pointed elsewhere already.
        # Tuples pointed at this object, ignore them.
        # Tuples pointed at another object, raise an error.
        tuple_hash_ = objdata_[2]
        new_tuple_list_.delete_if do |tup_|
          if tuple_hash_.has_key?(tup_)
            true
          elsif @tuples.has_key?(tup_)
            raise ObjectKeyError, "Could not rekey because one of the new tuples is already present"
          else
            false
          end
        end
        # Now go through and edit the tuples
        (tuple_hash_.keys - new_tuple_list_).each do |tup_|
          _remove_tuple(objdata_, tup_)
        end
        new_tuple_list_.each do |tup_|
          _add_tuple(objdata_, tup_)
        end
      end
    end
  end
  self
end

# File lib/idregistry/registry.rb, line 91
def size
  @objects.size
end

# File lib/idregistry/registry.rb, line 84
def spawn_registry(opts_={})
  config.spawn_registry(opts_)
end

# File lib/idregistry/registry.rb, line 117
def tuples_for(arg_)
  objdata_ = _get_objdata(arg_)
  objdata_ ? objdata_[2].keys : nil
end

# File lib/idregistry/registry.rb, line 183
def tuples_in_category(category_type_, *category_spec_)
  @config.lock

  return nil unless @categories.include?(category_type_)
  spec_ = category_spec_.size == 1 && category_spec_.first.is_a?(::Array) ? category_spec_.first : category_spec_
  tuple_hash_ = (@catdata[category_type_] ||= {})[spec_]
  tuple_hash_ ? tuple_hash_.keys : []
end