class IDL::AST::Initializer

def concrete_raises(instantiation_context)
  @raises.collect do |ex|
    ex.instantiate(instantiation_context)
  end
end

def initialize(_name, _enclosure, params)
  super(_name, _enclosure)
  @params = (params[:params] || []).collect do |(ptype, pname)|
    IDL::AST::Parameter.new(pname, self, {attribute: :in, type: ptype})
  end
  @raises = []
  self.raises = params[:raises]
end

def instantiate(instantiation_context, _enclosure)
  _params = {
    raises: self.concrete_raises(instantiation_context)
  }
  _init = super(instantiation_context, _enclosure, _params)
  _init.set_concrete_parameters(instantiation_context, @params)
  _init
end

def marshal_dump
  super() << @params << @raises
end

def marshal_load(vars)
  @raises = vars.pop
  @params = vars.pop
  super(vars)
end

def raises=(exlist)
  exlist.each do |extype|
    unless extype.is_a?(IDL::Type::ScopedName) &&
              (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
      raise 'Only IDL Exception types allowed in raises declaration.'
    end
    @raises << extype
  end
end

def set_concrete_parameters(instantiation_context, parms)
  @params = parms.collect do |parm|
    IDL::AST::Parameter.new(parm.name, self,
                       { attribute: :in,
                         type: parm.idltype.instantiate(instantiation_context) })
  end
end