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

class
	P2P_PEERGROUP_ADVERTISEMENT

inherit
	P2P_ADVERTISEMENT
		redefine
			initialize,
			document,
			validate
		end
	P2P_CREATORS_SHARED
		undefine
			out
		end

create
	make,
	make_from_element,
	parse_from_string,
	copy

feature {NONE} -- Initialization

	make (a_group_id: like group_id; a_module_specification_id: like module_specification_id) is
			-- Create new peer group advertisement
		require
			Gid_valid: a_group_id /= Void
			Msid_valid: a_module_specification_id /= Void
		do
			initialize
			set_group_id (a_group_id)
			set_module_specification_id (a_module_specification_id)

			is_valid := True
		ensure
			Gid_set: group_id.is_equal (a_group_id)
			Msid_set: module_specification_id.is_equal (a_module_specification_id)
		end

feature -- Access

	group_id: P2P_PEERGROUP_ID
	module_specification_id: P2P_MODULE_SPECIFICATION_ID
	name: STRING
	description: STRING

	service_parameters: DS_SPARSE_TABLE [P2P_XML_CACHE, P2P_MODULE_CLASS_ID] is
			-- Service parameters
		do
			Result := parameters.twin
		ensure
			Result_set: Result /= Void
		end

	has_service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID): BOOLEAN is
			-- Does service parameter `a_module_class_id' exist?
		require
			Id_existent: a_module_class_id /= Void
		do
			Result := parameters.has (a_module_class_id)
		end

	service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID): P2P_XML_CACHE is
			-- Parameter advertisement for service with given class id
		require
			Id_existent: a_module_class_id /= Void
		do
			if parameters.has (a_module_class_id) then
				Result := parameters.item (a_module_class_id)
			end
		ensure
			Result_set: has_service_parameter (a_module_class_id) implies Result /= Void
		end

	index_elements: DS_LIST [TUPLE [STRING, STRING]] is
			-- Indexable elements
		do
			create {DS_ARRAYED_LIST [TUPLE [STRING, STRING]]} Result.make (4)
			if name /= Void then
				Result.put_last ([element_name, name])
			end
			Result.put_last ([element_group_id, group_id.out])
			if description /= Void then
				Result.put_last ([element_description, description])
			end
			Result.put_last ([element_module_specification_id, module_specification_id.out])
		end

	unique_id: STRING is
			-- Unique id
		do
			Result := group_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_group_id.is_equal (an_element_name) then
				Result := does_element_match (group_id, an_element_value)
			elseif element_module_specification_id.is_equal (an_element_name) then
				Result := does_element_match (module_specification_id, 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)
			end
		end

feature -- Element change

	set_group_id (a_group_id: like group_id) is
			-- Set new group id
		require
			Gid_valid: a_group_id /= Void
		do
			group_id := a_group_id
			renew_document
		ensure
			Gid_set: group_id.is_equal (a_group_id)
		end

	set_module_specification_id (a_module_specification_id: like module_specification_id) is
			-- Set new module specification id
		require
			Msid_valid: a_module_specification_id /= Void
		do
			module_specification_id := a_module_specification_id
			renew_document
		ensure
			Msid_set: module_specification_id.is_equal (a_module_specification_id)
		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

	add_service_parameter, replace_service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID; a_parameter: P2P_XML_CACHE) is
			-- Add new service parameter for given module class
		require
			Mcid_valid: a_module_class_id /= Void
			Parameter_valid: a_parameter /= Void
		do
			parameters.force (a_parameter, a_module_class_id)
			renew_document
		ensure
			Parameter_set: service_parameter (a_module_class_id) = a_parameter
		end

feature -- Removal

	remove_service_parameter (a_module_class_id: P2P_MODULE_CLASS_ID) is
			-- Remove service parameter of given module class
		require
			Mcid_valid: a_module_class_id /= Void
		do
			parameters.remove (a_module_class_id)
			renew_document
		end

feature -- Output

	document: P2P_XML_DOCUMENT is
			-- Create XML document
		local
			cursor: DS_HASH_TABLE_CURSOR [P2P_XML_CACHE, P2P_MODULE_CLASS_ID]
			el_svc, el_parm_root: XM_ELEMENT
			mcid: P2P_MODULE_CLASS_ID
			parm: P2P_XML_CACHE
			parm_adv: P2P_ADVERTISEMENT
			cached: BOOLEAN
		do
			cached := cached_document /= Void
			-- create document
			Result := Precursor

			if not cached then
				-- element GID
				Result.create_root_child_element (element_group_id, Result.namespace_empty)
				Result.create_content (Result.last_element, group_id.out)
				-- element MSID
				Result.create_root_child_element (element_module_specification_id, Result.namespace_empty)
				Result.create_content (Result.last_element, module_specification_id.out)
				-- 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
				-- elements Svc
				from
					cursor := parameters.new_cursor
					cursor.start
				until
					cursor.after
				loop
					mcid := cursor.key
					parm := cursor.item
					Result.create_root_child_element (element_service_parameters, Result.namespace_empty)
					el_svc := Result.last_element
					Result.create_child_element (el_svc, element_service_parameter_mcid, Result.namespace_empty)
					Result.create_content (Result.last_element, mcid.out)
					parm_adv ?= parm
					-- paste document's root element into Parm element: use a copy, because the elements are double linked
					if parm_adv /= Void then
						-- parameter is an advertisement
						Result.create_child_element (el_svc, element_service_parameter_parm, Result.namespace_empty)
						Result.add_child_element (Result.last_element, parm.document.document.root_element.deep_twin)
					else
						-- parameter is an arbitrary xml document
						el_parm_root := parm.document.document.root_element.deep_twin
						el_parm_root.set_name (element_service_parameter_parm)
						el_parm_root.set_namespace (Result.namespace_empty)
						Result.add_child_element (el_svc, el_parm_root)
					end
					cursor.forth
				end
			end
		end

feature {NONE} -- Implementation

	parameters: DS_HASH_TABLE [P2P_XML_CACHE, P2P_MODULE_CLASS_ID]

	Element_group_id: STRING is "GID"
	Element_module_specification_id: STRING is "MSID"
	Element_name: STRING is "Name"
	Element_description: STRING is "Desc"
	Element_service_parameters: STRING is "Svc"
	Element_service_parameter_mcid: STRING is "MCID"
	Element_service_parameter_parm: STRING is "Parm"
	Type_group_id: STRING is "jxta:JXTAID"
	Type_module_specification_id: STRING is "jxta:JXTAID"
	Type_name: STRING is "xs:string"
	Type_description: STRING is "xs:anyType"
	Type_service_parameters: STRING is "jxta:serviceParams"
	Type_service_parameter_mcid: STRING is "jxta:JXTAID"
	Type_service_parameter_parm: STRING is "xs:anyType"

	root_element_name: STRING is "PGA"

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		local
			el_mcid, el_parm: XM_ELEMENT
			parm: P2P_XML_CACHE
			mcid: P2P_MODULE_CLASS_ID
		do
			if element_group_id.is_equal (element.name) then
				group_id := id_creator.create_peergroup_id (element_text (element))
			elseif element_module_specification_id.is_equal (element.name) then
				create module_specification_id.make_from_urn (element_text (element))
				if not module_specification_id.is_valid then
					module_specification_id := Void
				end
			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_service_parameters.is_equal (element.name) then
				el_mcid := element.element_by_name (element_service_parameter_mcid)
				el_parm := element.element_by_name (element_service_parameter_parm)
				if el_mcid /= Void and el_parm /= Void then
					create mcid.make_from_urn (element_text (el_mcid))
					-- try to extract document from element: use copy, because elements are double linked
					parm := xml_document_creator.document_from_element (el_parm.deep_twin)
					if parm /= Void and parm.is_valid then
						parameters.force (parm, mcid)
					end
				end
			end
		end

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

	initialize is
			-- Initialize object's data structure
		local
			equality_tester: KL_EQUALITY_TESTER [P2P_MODULE_CLASS_ID]
		do
			Precursor
			create equality_tester
			create parameters.make_default
			parameters.set_key_equality_tester (equality_tester)
		end

end