class IDL::AST::Home

def attributes(include_bases=false,traversed=nil)
  atts = @children.find_all { |c| c.is_a?(IDL::AST::Attribute) }
  atts.concat(base_attributes(traversed || [])) if include_bases
  atts
end

def initialize(_name, _enclosure, params)
  @component = nil
  @resolved_comp = nil
  @primarykey = nil
  @resolved_pk = nil
  @idltype = IDL::Type::Home.new(self)
  super(_name, _enclosure, params)
  set_component_and_key(params[:component], params[:primarykey])
end

def instantiate(_context, _enclosure)
  _params  = {
    :component => IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, @component)),
    :primarykey => @primarykey ? IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, @primarykey)) : @primarykey
  }
  # instantiate concrete home def and validate
  super(_context, _enclosure, _params)
end

def marshal_dump
  super() << @component << @resolved_comp << @primarykey << @resolved_pk
end

def marshal_load(vars)
  @resolved_pk = vars.pop
  @primarykey = vars.pop
  @resolved_comp = vars.pop
  @component = vars.pop
  super(vars)
end

def operations(include_bases=false,traversed=nil)
  ops = @children.find_all { |c| c.is_a?(IDL::AST::Operation) }
  ops.concat(base_operations(traversed || [])) if include_bases
  ops
end

def set_component_and_key(comp, key)
  unless comp && comp.is_a?(IDL::Type::ScopedName) && comp.is_node?(IDL::AST::TemplateParam)
    unless comp && comp.is_a?(IDL::Type::ScopedName) && comp.is_node?(IDL::AST::Component)
      raise (comp ?
              "invalid managed component for #{typename} #{scoped_lm_name}: #{comp.typename}" :
              "missing managed component specification for #{typename} #{scoped_lm_name}")
    end
    unless comp.resolved_type.node.is_defined?
      raise "#{scoped_lm_name}: #{comp.typename} cannot manage forward declared component #{comp.node.scoped_lm_name}"
    end
    @resolved_comp = comp.resolved_type.node
  end
  unless key && key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::TemplateParam)
    ## TODO : add check for Components::PrimaryKeyBase base type
    unless key.nil? || (key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::Valuetype))
      raise "invalid primary key for #{typename} #{scoped_lm_name}: #{key.typename}"
    end
    @resolved_pk = key.resolved_type.node if key
  end
  @component = comp.node
  @primarykey = key.node if key
end