indexing
	description: "An endpoint router message"
	license: "MIT license (see ../../../license.txt)"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

class
	P2P_ENDPOINT_ROUTER_MESSAGE

inherit
	P2P_XML_CACHE
		redefine
			initialize,
			document,
			validate
		end

create
	make,
	make_from_element,
	parse_from_string

feature {NONE} -- Initialization

	make (a_source: like source; a_destination: like destination) is
			-- Create new endpoint router message
		require
			Source_valid: a_source /= Void and a_source.is_valid
			Destination_valid: a_destination /= Void and a_destination.is_valid
		do
			initialize
			set_source (a_source)
			set_destination (a_destination)
			is_valid := True
		ensure
			Source_set: source = a_source
			Destination_set: destination = a_destination
		end

feature -- Access

	source: P2P_ENDPOINT_ADDRESS
	destination: P2P_ENDPOINT_ADDRESS
	last_hop: P2P_ENDPOINT_ADDRESS
	route: DS_LIST [P2P_ACCESSPOINT_ADVERTISEMENT]
	reverse_route: DS_LIST [P2P_ACCESSPOINT_ADVERTISEMENT]

	match (an_element_name, an_element_value: STRING): BOOLEAN is
			-- Is given element's value equal with `an_element_value'?
		do
			if element_source.is_equal (an_element_name) then
				Result := does_element_match (source, an_element_value)
			elseif element_destination.is_equal (an_element_name) then
				Result := does_element_match (destination, an_element_value)
			elseif element_last_hop.is_equal (an_element_name) then
				Result := does_element_match (last_hop, an_element_value)
			elseif element_route.is_equal (an_element_name) then
				Result := route.count /= 0
			elseif element_reverse_route.is_equal (an_element_name) then
				Result := reverse_route.count /= 0
			end
		end

feature -- Element change

	set_source (a_source: like source) is
			-- Set new source
		require
			Source_valid: a_source /= Void and a_source.is_valid
		do
			source := a_source
			renew_document
		ensure
			Source_set: source = a_source
		end

	set_destination (a_destination: like destination) is
			-- Set new destination
		require
			Destination_valid: a_destination /= Void and a_destination.is_valid
		do
			destination := a_destination
			renew_document
		ensure
			Destination_set: destination = a_destination
		end

	set_last_hop (a_last_hop: like last_hop) is
			-- Set new last_hop
		require
			Last_hop_valid: a_last_hop /= Void and a_last_hop.is_valid
		do
			last_hop := a_last_hop
			renew_document
		ensure
			Last_hop_set: last_hop = a_last_hop
		end

	add_route (an_apa: P2P_ACCESSPOINT_ADVERTISEMENT) is
			-- Add new route accesspoint advertisement
		require
			Apa_valid: an_apa /= Void and an_apa.is_valid
		do
			if not route.has (an_apa) then
				route.put_first (an_apa)
				renew_document
			end
		ensure
			Apa_added: route.has (an_apa)
		end

	add_reverse_route (an_apa: P2P_ACCESSPOINT_ADVERTISEMENT) is
			-- Add new reverse route accesspoint advertisement
		require
			Apa_valid: an_apa /= Void and an_apa.is_valid
		do
			if not reverse_route.has (an_apa) then
				reverse_route.put_first (an_apa)
				renew_document
			end
		ensure
			Apa_added: reverse_route.has (an_apa)
		end

feature -- Output

	document: P2P_XML_DOCUMENT is
			-- Create XML document
		local
			cached: BOOLEAN
			el_route: XM_ELEMENT
			route_cursor: DS_LIST_CURSOR [P2P_ACCESSPOINT_ADVERTISEMENT]
		do
			cached := cached_document /= Void
			-- create document
			Result := Precursor

			if not cached then
				-- element Src
				Result.create_root_child_element (element_source, Result.namespace_empty)
				Result.create_content (Result.last_element, source.out)
				-- element Dst
				Result.create_root_child_element (element_destination, Result.namespace_empty)
				Result.create_content (Result.last_element, destination.out)
				-- element LastHop
				if last_hop /= Void then
					Result.create_root_child_element (element_last_hop, Result.namespace_empty)
					Result.create_content (Result.last_element, last_hop.out)
				end
				-- element Fwd
				Result.create_root_child_element (element_route, Result.namespace_empty)
				el_route := Result.last_element
				from
					route_cursor := route.new_cursor
					route_cursor.start
				until
					route_cursor.after
				loop
					Result.add_child_element (el_route, route_cursor.item.document.document.root_element.twin)
					route_cursor.forth
				end
				-- element Rvs
				Result.create_root_child_element (element_reverse_route, Result.namespace_empty)
				el_route := Result.last_element
				from
					route_cursor := reverse_route.new_cursor
					route_cursor.start
				until
					route_cursor.after
				loop
					Result.add_child_element (el_route, route_cursor.item.document.document.root_element.twin)
					route_cursor.forth
				end
			end
		end

feature {NONE} -- Implementation

	Element_source: STRING is "Src"
	Element_destination: STRING is "Dest"
	Element_last_hop: STRING is "LastHop"
	Element_route: STRING is "Fwd"
	Element_reverse_route: STRING is "Rvs"

	root_element_name: STRING is "ERM"

	attribute_handler (root_attribute: XM_ATTRIBUTE) is
			-- No attributes to handle
		do
		end

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		do
			if element_source.is_equal (element.name) then
				create source.make_from_uri (element_text (element))
				if not source.is_valid then
					source := Void
				end
			elseif element_destination.is_equal (element.name) then
				create destination.make_from_uri (element_text (element))
				if not destination.is_valid then
					destination := Void
				end
			elseif element_last_hop.is_equal (element.name) then
				create last_hop.make_from_uri (element_text (element))
				if not last_hop.is_valid then
					last_hop := Void
				end
			elseif element_route.is_equal (element.name) then
				fetch_apas (element, route)
			elseif element_reverse_route.is_equal (element.name) then
				fetch_apas (element, reverse_route)
			end
		end

	initialize is
			-- Initialize data structures
		local
			apa_equality_tester: KL_EQUALITY_TESTER [P2P_ACCESSPOINT_ADVERTISEMENT]
		do
			Precursor
			create apa_equality_tester
			create {DS_LINKED_LIST [P2P_ACCESSPOINT_ADVERTISEMENT]} route.make
			route.set_equality_tester (apa_equality_tester)
			create {DS_LINKED_LIST [P2P_ACCESSPOINT_ADVERTISEMENT]} reverse_route.make
			reverse_route.set_equality_tester (apa_equality_tester)
		end

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

	fetch_apas (an_element: XM_ELEMENT; a_list: like route) is
			-- Fetch accesspoint advertisements from `an_element' and stores them in `a_list'
		require
			Element_valid: an_element /= Void
			List_valid: a_list /= Void
		local
			el_apa: XM_ELEMENT
			apa: P2P_ACCESSPOINT_ADVERTISEMENT
		do
			from
				an_element.start
			until
				an_element.after
			loop
				el_apa ?= an_element.item_for_iteration
				if el_apa /= Void then
					create apa.make_from_element (el_apa.twin)
					if apa.is_valid then
						a_list.put_last (apa)
					end
				end
				an_element.forth
			end
		end

invariant
	Route_existent: route /= Void and route.equality_tester /= Void
	Reverse_route_existent: reverse_route /= Void and reverse_route.equality_tester /= Void

end