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

class
	P2P_RENDEZVOUS_ADVERTISEMENT

inherit
	P2P_ADVERTISEMENT
		redefine
			document,
			validate
		end

create
	make,
	make_from_element,
	parse_from_string

feature {NONE} -- Initialization

	make (a_group_id: like group_id; a_peer_id: like peer_id; a_service_name: like service_name) is
			-- Create new rendezvous advertisement
		require
			Group_id_valid: a_group_id /= Void and a_group_id.is_valid
			Peer_id_valid: a_peer_id /= Void and a_peer_id.is_valid
			Service_name_valid: a_service_name /= Void
		do
			initialize
			set_group_id (a_group_id)
			set_peer_id (a_peer_id)
			set_service_name (a_service_name)

			is_valid := True
		ensure
			Group_id_set: group_id.is_equal (a_group_id)
			Peer_id_set: peer_id.is_equal (a_peer_id)
			Service_name_set: service_name.is_equal (a_service_name)
		end

feature -- Access

	group_id: P2P_PEERGROUP_ID
	peer_id: P2P_PEER_ID
	service_name: STRING -- Peer view to which the rendezvous peer belongs
	name: STRING
	route: P2P_ROUTE_ADVERTISEMENT

	index_elements: DS_LIST [TUPLE [STRING, STRING]] is
			-- Indexable elements
		do
			create {DS_ARRAYED_LIST [TUPLE [STRING, STRING]]} Result.make (3)
			Result.put_last ([element_peer_id, peer_id.out])
			Result.put_last ([element_service_name, service_name])
			Result.put_last ([element_group_id, group_id.out])
		end

	unique_id: STRING is
			-- Unique id
		do
			Result := root_element_name + "-" + group_id.out_short + "-" + peer_id.out_short + "-" + service_name
		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_peer_id.is_equal (an_element_name) then
				Result := does_element_match (peer_id, an_element_value)
			elseif element_service_name.is_equal (an_element_name) then
				Result := does_element_match (service_name, an_element_value)
			elseif element_name.is_equal (an_element_name) then
				Result := does_element_match (name, an_element_value)
			end
		end

feature -- Element change

	set_group_id (a_group_id: like group_id) is
			-- Set new group id
		require
			Id_valid: a_group_id /= Void and a_group_id.is_valid
		do
			group_id := a_group_id
			renew_document
		ensure
			Id_set: group_id.is_equal (a_group_id)
		end

	set_peer_id (a_peer_id: like peer_id) is
			-- Set new peer id
		require
			Id_valid: a_peer_id /= Void and a_peer_id.is_valid
		do
			peer_id := a_peer_id
			renew_document
		ensure
			Id_set: peer_id.is_equal (a_peer_id)
		end

	set_service_name (a_service_name: like service_name) is
			-- Set new service name
		require
			Service_name_valid: a_service_name /= Void
		do
			service_name := a_service_name
			renew_document
		ensure
			Service_name_set: service_name.is_equal (a_service_name)
		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_route (a_route: like route) is
			-- Set new route
		require
			Route_valid: a_route /= Void and a_route.is_valid
		do
			route := a_route
			renew_document
		ensure
			Route_set: route.is_equal (a_route)
		end

feature -- Output

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

			if not cached then
				-- element RdvGroupId
				Result.create_root_child_element (element_group_id, Result.namespace_empty)
				Result.create_content (Result.last_element, group_id.out)
				-- element RdvPeerId
				Result.create_root_child_element (element_peer_id, Result.namespace_empty)
				Result.create_content (Result.last_element, peer_id.out)
				-- RdvServiceName
				Result.create_root_child_element (element_service_name, Result.namespace_empty)
				Result.create_content (Result.last_element, service_name)
				-- Name
				if name /= Void then
					Result.create_root_child_element (element_name, Result.namespace_empty)
					Result.create_content (Result.last_element, name)
				end
				-- element RdvRoute
				if route /= Void then
					Result.create_root_child_element (element_route, Result.namespace_empty)
					Result.add_child_element (Result.last_element, route.document.document.root_element.deep_twin)
				end
			end
		end

feature {NONE} -- Implementation

	Element_group_id: STRING is "RdvGroupId"
	Element_peer_id: STRING is "RdvPeerId"
	Element_service_name: STRING is "RdvServiceName"
	Element_name: STRING is "Name"
	Element_route: STRING is "RdvRoute"
	Type_group_id: STRING is "jxta:JXTAID"
	Type_peer_id: STRING is "jxta:JXTAID"
	Type_service_name: STRING is "xs:string"
	Type_name: STRING is "xs:string"
	Type_route: STRING is "xs:anyType"

	root_element_name: STRING is "RdvAdvertisement"

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		local
			children: DS_LIST [XM_ELEMENT]
		do
			if element_group_id.is_equal (element.name) then
				group_id := id_creator.create_peergroup_id (element_text (element))
			elseif element_peer_id.is_equal (element.name) then
				create peer_id.make_from_urn (element_text (element))
				if not peer_id.is_valid then
					peer_id := Void
				end
			elseif element_service_name.is_equal (element.name) then
				service_name := trimmed (element.text)
			elseif element_name.is_equal (element.name) then
				name := trimmed (element.text)
			elseif element_route.is_equal (element.name) then
				children := element.elements
				if children.count > 0 then
					create route.make_from_element (children.first.deep_twin)
					if not route.is_valid then
						route := Void
					end
				end
			end
		end

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

end