module PIM::AttributeTemplates

# File pim.rb, line 5225
def AdditionalCategory(additional_module_name, additional_category_name = nil)
  additional_module_name = additional_module_name.to_s
  additional_category_name = additional_category_name.to_s
  additional_module = PIM.get_module(additional_module_name)
  raise "Additional module '#{additional_module_name}' is not defined" if !additional_module
  if additional_category_name
    additional_category = query_module_category(additional_module, additional_category_name)
    raise "Category '#{additional_category_name}' is not defined in additional module '#{additional_module_name}'" if !additional_category
  end
  params = {
    :additional_module => additional_module_name,
    :additional_category => additional_category_name
  }
  service_name = additional_module.service_name
  params[:extension] = service_name unless PIM.is_empty?(service_name)
  return AttributeTemplate.new("AdditionalCategory", String, params)
end

# File pim.rb, line 5346
def Boolean(values = { :true => "True", :false => "False" })
  check_options values, type: 'Boolean', param: 'values'
  params = { :values => values }
  params[:renderer] = 'SingleBoolean' if values.length == 1
  return AttributeTemplate.new("Boolean", String, params)
end

# File pim.rb, line 5369
def Codelist(codelist_name)
  return AttributeTemplate.new("Codelist", String, { :codelist => codelist_name })
end

# File pim.rb, line 5377
def CodelistSet(codelist_name)
  return AttributeTemplate.new("CodelistSet", Array, {
    :codelist => codelist_name,
    :to_xml => ENUM_SET_TO_XML,
    :xml_key => 'seq',
    :uniq => true
  })
end

# File pim.rb, line 5514
def Collection(value_attribute)
  attribute = data_module.attribute(value_attribute)
  raise "Attribute '#{value_attribute}' used in collection type is not defined" if !attribute
  raise "Attribute '#{value_attribute}' used in collection type must be of class Composite" if !(attribute.base_class <= Composite)
  return AttributeTemplate.new("Collection", Array, { :value_attribute => value_attribute })
end

# File pim.rb, line 5505
def Composite(*args)
  composite = PIM::Composite.new(*args)
  DataModuleObject.set_data_module(composite, data_module)
  return composite
end

# File pim.rb, line 5245
def Date(format = "mediumDate")
  return AttributeTemplate.new("Date", Date, { :format => format })
end

# File pim.rb, line 5251
def DateTime(format = "medium")
  return AttributeTemplate.new("DateTime", DateTime, { :format => format })
end

# File pim.rb, line 5258
def Dimensional(*args)

  if args.length == 1
    value_class = String
    keys = args[0]
  elsif args.length == 2
    value_class = args[0]
    keys = args[1]
  else
    raise "Wrong number of arguments: Expected either value class and dimensional keys or only dimensional keys"
  end

  check_options keys, type: 'Dimensional', param: 'keys'
  return AttributeTemplate.new('Dimensional', Hash, {
    :keys => keys,
    :value_class => value_class,
    :dimension_xml_key => 'lang',
    :to_xml => DIMENSIONAL_TO_XML
  })

end

# File pim.rb, line 5363
def Document()
  return AttributeTemplate.new("Document", String, {
    :check_url => true
  })
end

# File pim.rb, line 5337
def DynamicEnum(dynamic_values_url)
  return AttributeTemplate.new("Enum", String, { :values => {}, :dynamic_values_url => dynamic_values_url })
end

# File pim.rb, line 5296
def Enum(values)
  check_options values, type: 'Enum', param: 'values'
  return AttributeTemplate.new("Enum", String, { :values => values })
end

# File pim.rb, line 5310
def EnumSet(value_attribute)
  attribute = data_module.attribute(value_attribute)
  raise "Attribute '#{value_attribute}' used in enum-set type is not defined" if !attribute
  raise "Attribute '#{value_attribute}' used in enum-set type must be of type Enum" if attribute.type_name != 'Enum'
  return AttributeTemplate.new('EnumSet', Array, {
    :value_attribute => value_attribute,
    :to_xml => ENUM_SET_TO_XML,
    :xml_key => 'seq',
    :uniq => true
  })
end

# File pim.rb, line 5524
def Group(value_attribute)
  attribute = data_module.attribute(value_attribute)
  raise "Attribute '#{value_attribute}' used in group type is not defined" if !attribute
  raise "Attribute '#{value_attribute}' used in group type must be of class Composite" if !(attribute.base_class <= Composite)
  return AttributeTemplate.new("Group", Array, { :value_attribute => value_attribute })
end

# File pim.rb, line 5355
def Image()
  return AttributeTemplate.new("Image", String, {
    :check_url => true
  })
end

# File pim.rb, line 5544
def MultiDimensional(key_members, value_members)
  multi_dimensional = PIM::MultiDimensional.new(data_module, key_members, value_members)
  DataModuleObject.set_data_module(multi_dimensional, data_module)
  return multi_dimensional
end

# File pim.rb, line 5531
def MultiReference(value_attribute)
  attribute = data_module.attribute(value_attribute)
  raise "Attribute '#{value_attribute}' used in multi-reference type is not defined" if !attribute
  raise "Attribute '#{value_attribute}' used in multi-reference type must be of class Composite" if !(attribute.base_class <= Composite)
  return AttributeTemplate.new("MultiReference", Array, { :value_attribute => value_attribute })
end

# File pim.rb, line 5373
def OpenCodelist(codelist_name)
  return AttributeTemplate.new("OpenCodelist", String, { :codelist => codelist_name, :skip_values_validation => true })
end

# File pim.rb, line 5386
def OpenCodelistSet(codelist_name)
  return AttributeTemplate.new("OpenCodelistSet", Array, {
    :codelist => codelist_name,
    :skip_values_validation => true,
    :to_xml => ENUM_SET_TO_XML,
    :xml_key => 'seq',
    :uniq => true
  })
end

# File pim.rb, line 5284
def OpenDimensional(value_class = String, keys = {})
  check_options keys, type: 'OpenDimensional', param: 'keys' unless PIM.is_empty?(keys)
  return AttributeTemplate.new('OpenDimensional', Hash, {
    :keys => keys,
    :value_class => value_class,
    :skip_keys_validation => true,
    :dimension_xml_key => 'lang',
    :to_xml => DIMENSIONAL_TO_XML
  })
end

# File pim.rb, line 5302
def OpenEnum(values)
  check_options values, type: 'OpenEnum', param: 'values' unless PIM.is_empty?(values)
  return AttributeTemplate.new("OpenEnum", String, { :values => values, :skip_values_validation => true })
end

# File pim.rb, line 5324
def OpenEnumSet(value_attribute)
  attribute = data_module.attribute(value_attribute)
  raise "Attribute '#{value_attribute}' used in open-enum-set type is not defined" if !attribute
  raise "Attribute '#{value_attribute}' used in open-enum-set type must be of type OpenEnum" if attribute.type_name != 'OpenEnum'
  return AttributeTemplate.new('OpenEnumSet', Array, {
    :value_attribute => value_attribute,
    :to_xml => ENUM_SET_TO_XML,
    :xml_key => 'seq',
    :uniq => true
  })
end

# File pim.rb, line 5550
def Password()
  return AttributeTemplate.new("Password", String)
end

# File pim.rb, line 5480
def Physical(units, *group_names)
  check_options units, type: 'Physical', param: 'keys'
  params = {
    :keys => units,
    :value_class => Float,
    :formatter => PHYSICAL_FORMATTER,
    :parser => PHYSICAL_PARSER,
    :maxLength => 1,
    :to_xml => PHYSICAL_TO_XML
  }
  if group_names.size == 1 and is_array?(group_names[0])
    group_names = group_names[0]
  end
  params[:keys_option_groups] = group_names unless group_names.empty?
  return AttributeTemplate.new('Physical', Hash, params)
end

# File pim.rb, line 5498
def PhysicalInteger(units, *group_names)
  attributeTemplate = Physical(units, group_names)
  attributeTemplate.param(:value_class, Integer)
  attributeTemplate
end

# File pim.rb, line 5538
def SingleReference()
  return AttributeTemplate.new("SingleReference", String)
end