indexing
	description: "Represents a module implementation advertisement"
	license: "MIT license (see ../license.txt)"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

class
	P2P_MODULE_IMPLEMENTATION_ADVERTISEMENT

inherit
	P2P_ADVERTISEMENT
		redefine
			document,
			validate
		end
	P2P_CREATORS_SHARED
		undefine
			out
		end

create
	make,
	make_from_element,
	parse_from_string

feature {NONE} -- Initialization

	make (a_specification_id: like specification_id; a_compatibility: like compatibility; a_code: like code) is
			-- Create new module implementation advertisement
		require
			Spec_valid: a_specification_id /= Void
			Comp_valid: a_compatibility /= Void
			Code_valid: a_code /= Void
		do
			initialize
			set_specification_id (a_specification_id)
			set_compatibility (a_compatibility)
			set_code (a_code)

			is_valid := True
		ensure
			Spec_set: specification_id.is_equal (a_specification_id)
			Comp_set: compatibility.is_equal (a_compatibility)
			Code_set: code.is_equal (a_code)
		end

feature -- Access

	specification_id: P2P_MODULE_SPECIFICATION_ID
	compatibility: STRING
	code: STRING
	package_uri: STRING
	provider: STRING
	description: STRING
	parameter: P2P_ADVERTISEMENT

	index_elements: DS_LIST [TUPLE [STRING, STRING]] is
			-- Indexable elements
		do
			create {DS_ARRAYED_LIST [TUPLE [STRING, STRING]]} Result.make (1)
			Result.put_last ([element_specification_id, specification_id.out])
		end

	unique_id: STRING is
			-- Unique id
		do
		end

	match (an_element_name, an_element_value: STRING): BOOLEAN is
			-- Is given element's value equal with `an_element_value'?
		do
			if element_specification_id.is_equal (an_element_name) then
				Result := does_element_match (specification_id, an_element_value)
			elseif element_compatibility.is_equal (an_element_name) then
				Result := does_element_match (compatibility, an_element_value)
			elseif element_code.is_equal (an_element_name) then
				Result := does_element_match (code, an_element_value)
			elseif element_package_uri.is_equal (an_element_name) then
				Result := does_element_match (package_uri, an_element_value)
			elseif element_provider.is_equal (an_element_name) then
				Result := does_element_match (provider, an_element_value)
			elseif element_description.is_equal (an_element_name) then
				Result := does_element_match (description, an_element_value)
			end
		end

feature -- Element change

	set_specification_id (a_specification_id: like specification_id) is
			-- Set new specification id
		require
			Id_valid: a_specification_id /= Void
		do
			specification_id := a_specification_id
			renew_document
		ensure
			Id_set: specification_id.is_equal (a_specification_id)
		end

	set_compatibility (a_compatibility: like compatibility) is
			-- Set new compatibility
		require
			Comp_valid: a_compatibility /= Void
		do
			compatibility := a_compatibility
			renew_document
		ensure
			Comp_set: compatibility.is_equal (a_compatibility)
		end

	set_code (a_code: like code) is
			-- Set new compatibility
		require
			Code_valid: a_code /= Void
		do
			code := a_code
			renew_document
		ensure
			Code_set: code.is_equal (a_code)
		end

	set_package_uri (a_puri: like package_uri) is
			-- Set new package URI
		require
			Puri_valid: a_puri /= Void
		do
			package_uri := a_puri
			renew_document
		ensure
			Puri_set: package_uri.is_equal (a_puri)
		end

	set_provider (a_provider: like provider) is
			-- Set new provider
		require
			Provider_valid: a_provider /= Void
		do
			provider := a_provider
			renew_document
		ensure
			Provider_set: provider.is_equal (a_provider)
		end

	set_description (a_description: like description) is
			-- Set new description
		require
			Description_valid: a_description /= Void
		do
			description := a_description
			renew_document
		ensure
			Description_set: description.is_equal (a_description)
		end

	set_parameter (a_parameter: like parameter) is
			-- Set new parameter
		require
			Parameter_valid: a_parameter /= Void
		do
			parameter := a_parameter
			renew_document
		ensure
			Parameter_set: parameter.is_equal (a_parameter)
		end

feature -- Output

	document: P2P_XML_DOCUMENT is
			-- Create XML document
		local
			element: XM_ELEMENT
			cached: BOOLEAN
		do
			cached := cached_document /= Void
			-- create document
			Result := Precursor

			if not cached then
				-- element MSID
				Result.create_root_child_element (element_specification_id, Result.namespace_empty)
				Result.create_content (Result.last_element, specification_id.out)
				-- element Comp
				Result.create_root_child_element (element_compatibility, Result.namespace_empty)
				Result.create_content (Result.last_element, compatibility)
				-- element Code
				Result.create_root_child_element (element_code, Result.namespace_empty)
				Result.create_content (Result.last_element, code)
				-- element PURI
				if package_uri /= Void then
					Result.create_root_child_element (element_package_uri, Result.namespace_empty)
					Result.create_content (Result.last_element, package_uri)
				end
				-- element Prov
				if provider /= Void then
					Result.create_root_child_element (element_provider, Result.namespace_empty)
					Result.create_content (Result.last_element, provider)
				end
				-- element Desc
				if description /= Void then
					Result.create_root_child_element (element_description, Result.namespace_empty)
					Result.create_content (Result.last_element, description)
				end
				-- element Parm
				if parameter /= Void then
					-- use copy, because elements are double linked
					element := parameter.document.document.root_element.deep_twin
					element.set_name (element_parameter)
					element.set_namespace (Result.namespace_empty)
					Result.add_child_element (Result.document.root_element, element)
				end
			end
		end

feature {NONE} -- Implementation

	Element_specification_id: STRING is "MSID"
	Element_compatibility: STRING is "Comp"
	Element_code: STRING is "Code"
	Element_package_uri: STRING is "PURI"
	Element_provider: STRING is "Prov"
	Element_description: STRING is "Desc"
	Element_parameter: STRING is "Parm"
	Type_specification_id: STRING is "jxta:JXTAID"
	Type_compatibility: STRING is "xs:anyType"
	Type_code: STRING is "xs:anyType"
	Type_package_uri: STRING is "xs:anyURI"
	Type_provider: STRING is "xs:string"
	Type_description: STRING is "xs:anyType"
	Type_parameter: STRING is "xs:anyType"

	root_element_name: STRING is "MIA"

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		do
			if element_specification_id.is_equal (element.name) then
				create specification_id.make_from_urn (element_text (element))
				if not specification_id.is_valid then
					specification_id := Void
				end
			elseif element_compatibility.is_equal (element.name) then
				compatibility := trimmed (element.text)
			elseif element_code.is_equal (element.name) then
				code := trimmed (element.text)
			elseif element_package_uri.is_equal (element.name) then
				package_uri := trimmed (element.text)
			elseif element_provider.is_equal (element.name) then
				provider := trimmed (element.text)
			elseif element_description.is_equal (element.name) then
				description := trimmed (element.text)
			elseif element_parameter.is_equal (element.name) then
				-- use copy, because elements are double linked
				parameter := xml_document_creator.advertisement_from_element (element.deep_twin)
			end
		end

	validate is
			-- Validate advertisement and set `is_valid'
		do
			is_valid := is_valid and specification_id /= Void and compatibility /= Void and code /= Void
		end

end