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

class
	P2P_MODULE_SPECIFICATION_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_version: like version) is
			-- Create new module specification advertisement
		require
			Msid_valid: a_specification_id /= Void
			Version_valid: a_version /= Void
		do
			initialize
			set_specification_id (a_specification_id)
			set_version (a_version)

			is_valid := True
		ensure
			Spec_set: specification_id.is_equal (a_specification_id)
			Version_set: version.is_equal (a_version)
		end

feature -- Access

	specification_id: P2P_MODULE_SPECIFICATION_ID
	version: STRING
	name: STRING
	description: STRING
	creator: STRING
	specification_uri: STRING
	parameter: P2P_ADVERTISEMENT
	pipe: P2P_PIPE_ADVERTISEMENT
	proxy: STRING
	authenticator: P2P_MODULE_SPECIFICATION_ID

	index_elements: DS_LIST [TUPLE [STRING, STRING]] is
			-- Indexable elements
		do
			if name /= Void then
				create {DS_ARRAYED_LIST [TUPLE [STRING, STRING]]} Result.make (2)
				Result.put_last ([element_name, name])
			else
				create {DS_ARRAYED_LIST [TUPLE [STRING, STRING]]} Result.make (1)
			end
			Result.put_last ([element_specification_id, specification_id.out])
		end

	unique_id: STRING is
			-- Unique id
		do
			Result := specification_id.out_short
		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_version.is_equal (an_element_name) then
				Result := does_element_match (version, an_element_value)
			elseif element_name.is_equal (an_element_name) then
				Result := does_element_match (name, an_element_value)
			elseif element_description.is_equal (an_element_name) then
				Result := does_element_match (description, an_element_value)
			elseif element_creator.is_equal (an_element_name) then
				Result := does_element_match (creator, an_element_value)
			elseif element_specification_uri.is_equal (an_element_name) then
				Result := does_element_match (specification_uri, an_element_value)
			elseif element_proxy.is_equal (an_element_name) then
				Result := does_element_match (proxy, 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_version (a_version: like version) is
			-- Set new version
		require
			Version_valid: a_version /= Void
		do
			version := a_version
			renew_document
		ensure
			Version_set: version.is_equal (a_version)
		end

	set_name (a_name: like name) is
			-- Set new name
		require
			Name_valid: a_name /= Void
		do
			name := a_name
			renew_document
		ensure
			Name_set: name.is_equal (a_name)
		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_creator (a_creator: like creator) is
			-- Set new creator
		require
			Creator_valid: a_creator /= Void
		do
			creator := a_creator
			renew_document
		ensure
			Creator_set: creator.is_equal (a_creator)
		end

	set_specification_uri (a_specification_uri: like specification_uri) is
			-- Set new specification uri
		require
			Suri_valid: a_specification_uri /= Void
		do
			specification_uri := a_specification_uri
			renew_document
		ensure
			Suri_set: specification_uri.is_equal (a_specification_uri)
		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

	set_pipe (a_pipe: like pipe) is
			-- Set new pipe
		require
			Pipe_valid: a_pipe /= Void
		do
			pipe := a_pipe
			renew_document
		ensure
			Pipe_set: pipe.is_equal (a_pipe)
		end

	set_proxy (a_proxy: like proxy) is
			-- Set new proxy
		require
			Proxy_valid: a_proxy /= Void
		do
			proxy := a_proxy
			renew_document
		ensure
			Proxy_set: proxy.is_equal (a_proxy)
		end

	set_authenticator (an_authenticator: like authenticator) is
			-- Set new authenticator
		require
			Authenticator_valid: an_authenticator /= Void
		do
			authenticator := an_authenticator
			renew_document
		ensure
			Authenticator_set: authenticator.is_equal (an_authenticator)
		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 Vers
				Result.create_root_child_element (element_version, Result.namespace_empty)
				Result.create_content (Result.last_element, version)
				-- element Name
				if name /= Void then
					Result.create_root_child_element (element_name, Result.namespace_empty)
					Result.create_content (Result.last_element, name)
				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 Crtr
				if creator /= Void then
					Result.create_root_child_element (element_creator, Result.namespace_empty)
					Result.create_content (Result.last_element, creator)
				end
				-- element SURI
				if specification_uri /= Void then
					Result.create_root_child_element (element_specification_uri, Result.namespace_empty)
					Result.create_content (Result.last_element, specification_uri)
				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
				-- ref PipeAdvertisement
				if pipe /= Void then
					-- use copy, because elements are double linked
					Result.add_child_element (Result.document.root_element, pipe.document.document.root_element.deep_twin)
				end
				-- element Proxy
				if proxy /= Void then
					Result.create_root_child_element (element_proxy, Result.namespace_empty)
					Result.create_content (Result.last_element, proxy)
				end
				-- element Auth
				if authenticator /= Void then
					Result.create_root_child_element (element_authenticator, Result.namespace_empty)
					Result.create_content (Result.last_element, authenticator.out)
				end
			end
		end

feature {NONE} -- Implementation

	Element_specification_id: STRING is "MSID"
	Element_version: STRING is "Vers"
	Element_name: STRING is "Name"
	Element_description: STRING is "Desc"
	Element_creator: STRING is "Crtr"
	Element_specification_uri: STRING is "SURI"
	Element_parameter: STRING is "Parm"
	Element_pipe: STRING is "PipeAdvertisement"
	Element_proxy: STRING is "Proxy"
	Element_authenticator: STRING is "Auth"
	Type_specification_id: STRING is "jxta:JXTAID"
	Type_version: STRING is "xs:string"
	Type_name: STRING is "xs:string"
	Type_description: STRING is "xs:anyType"
	Type_creator: STRING is "xs:string"
	Type_specification_uri: STRING is "xs:anyURI"
	Type_parameter: STRING is "xs:anyType"
	Type_pipe: STRING is "jxta:PipeAdvertisement"
	Type_proxy: STRING is "xs:anyURI"
	Type_authenticator: STRING is "jxta:JXTAID"

	root_element_name: STRING is "MSA"

	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_version.is_equal (element.name) then
				version := trimmed (element.text)
			elseif element_name.is_equal (element.name) then
				name := trimmed (element.text)
			elseif element_description.is_equal (element.name) then
				description := trimmed (element.text)
			elseif element_creator.is_equal (element.name) then
				creator := trimmed (element.text)
			elseif element_specification_uri.is_equal (element.name) then
				specification_uri := 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)
			elseif element_pipe.is_equal (element.name) then
				-- use copy, because elements are double linked
				create pipe.make_from_element (element.deep_twin)
			elseif element_proxy.is_equal (element.name) then
				proxy := trimmed (element.text)
			elseif element_authenticator.is_equal (element.name) then
				create authenticator.make_from_urn (element_text (element))
				if not authenticator.is_valid then
					authenticator := Void
				end
			end
		end

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

end