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

class
	O_SERVICE_ROLE_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_peer_id: like peer_id; a_type: like type; a_name: like name; a_role: like role; a_status: like status) is
			-- Create new Origo service role advertisement
		require
			Pid_valid: a_peer_id /= Void and a_peer_id.is_valid
			Type_valid: a_type >= 0
			Name_valid: a_name /= Void and not a_name.is_empty
			Role_valid: a_role /= Void and not a_role.is_empty
			Status_valid: a_status >= 0
		do
			initialize
			set_peer_id (a_peer_id)
			set_type (a_type)
			set_name (a_name)
			set_role (a_role)
			set_status (a_status)
			is_valid := True
		ensure
			Pid_set: peer_id.is_equal (a_peer_id)
			Type_set: type = a_type
			Name_set: name.is_equal (a_name)
			Role_set: role.is_equal (a_role)
			Status_set: status = a_status
		end

feature -- Access

	peer_id: P2P_PEER_ID
	type: INTEGER
	name: STRING
	role: STRING
	status: INTEGER
	configuration: P2P_XML_CACHE

	Status_initialized: INTEGER is 0
	Status_started: INTEGER is 1
	Status_suspended: INTEGER is 2

	index_elements: DS_LIST [TUPLE [STRING, STRING]] is
			-- Indexable elements
		do
			create {DS_ARRAYED_LIST [TUPLE [STRING, STRING]]} Result.make (4)
			Result.put_last ([element_peer_id, peer_id.out])
			Result.put_last ([element_type, type.out])
			Result.put_last ([element_name, name])
			Result.put_last ([element_role, role])
		end

	unique_id: STRING is
			-- Unique id
		do
			Result := "OrigoServiceRoleAdvertisement/" + type.out + "/" + name + "/" + role
		end

	match (an_element_name, an_element_value: STRING): BOOLEAN is
			-- Is given element's value equal with `an_element_value'?
		do
			if element_peer_id.is_equal (an_element_name) then
				Result := does_element_match (peer_id, an_element_value)
			elseif element_type.is_equal (an_element_name) then
				Result := does_element_match (type, an_element_value)
			elseif element_name.is_equal (an_element_name) then
				Result := does_element_match (name, an_element_value)
			elseif element_role.is_equal (an_element_name) then
				Result := does_element_match (role, an_element_value)
			elseif element_status.is_equal (an_element_name) then
				Result := does_element_match (status, an_element_value)
			end
		end

feature -- Element change

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

	set_type (a_type: like type) is
			-- Set new type
		require
			Type_valid: a_type >= 0
		do
			type := a_type
			renew_document
		ensure
			Type_set: type = a_type
		end

	set_name (a_name: like name) is
			-- Set new name
		require
			Name_valid: a_name /= Void and not a_name.is_empty
		do
			name := a_name
			renew_document
		ensure
			Name_set: name.is_equal (a_name)
		end

	set_role (a_role: like role) is
			-- Set new role
		require
			Role_valid: a_role /= Void and not a_role.is_empty
		do
			role := a_role
			renew_document
		ensure
			Role_set: role.is_equal (a_role)
		end

	set_status (a_status: like status) is
			-- Set new status
		require
			Status_valid: a_status >= 0
		do
			status := a_status
			renew_document
		ensure
			Status_set: status = a_status
		end

	set_configuration (a_configuration: like configuration) is
			-- Set new configuration
		require
			Configuration_valid: a_configuration /= Void and a_configuration.is_valid
		do
			configuration := a_configuration
			renew_document
		ensure
			Configuration_set: configuration.is_equal (a_configuration)
		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 PID
				Result.create_root_child_element (element_peer_id, Result.namespace_empty)
				Result.create_content (Result.last_element, peer_id.out)
				-- element Type
				Result.create_root_child_element (element_type, Result.namespace_empty)
				Result.create_content (Result.last_element, type.out)
				-- element Name
				Result.create_root_child_element (element_name, Result.namespace_empty)
				Result.create_content (Result.last_element, name)
				-- element Role
				Result.create_root_child_element (element_role, Result.namespace_empty)
				Result.create_content (Result.last_element, role)
				-- Element State
				Result.create_root_child_element (element_status, Result.namespace_empty)
				Result.create_content (Result.last_element, status.out)
				-- Element Conf
				if configuration /= Void then
					Result.create_root_child_element (element_configuration, Result.namespace_empty)
					-- use a copy, because the elements are double linked
					Result.add_child_element (Result.last_element, configuration.document.document.root_element.deep_twin)
				end
			end
		end

feature {NONE} -- Implementation

	Element_peer_id: STRING is "PID"
	Element_type: STRING is "Type"
	Element_name: STRING is "Name"
	Element_role: STRING is "Role"
	Element_status: STRING is "State"
	Element_configuration: STRING is "Conf"

	root_element_name: STRING is "OrigoServiceRole"

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		local
			value: STRING
			el_config: XM_ELEMENT
		do
			if 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_type.is_equal (element.name) then
				value := trimmed (element.text)
				if value /= Void and value.is_integer then
					type := value.to_integer
				else
					type := -1 -- invalid
				end
			elseif element_name.is_equal (element.name) then
				name := trimmed (element.text)
			elseif element_role.is_equal (element.name) then
				role := trimmed (element.text)
			elseif element_status.is_equal (element.name) then
				value := trimmed (element.text)
				if value /= Void and value.is_integer then
					status := value.to_integer
				else
					status := -1 -- invalid
				end
			elseif element_configuration.is_equal (element.name) then
				if not element.is_empty then
					el_config ?= element.first
					if el_config /= Void then
						configuration := xml_document_creator.document_from_element (el_config.deep_twin)
					end
				end
			end
		end

	validate is
			-- Validate advertisement and set `is_valid'
		do
			is_valid := is_valid and peer_id /= Void and name /= Void and not name.is_empty and
				role /= Void and not role.is_empty and status >= 0
		end

end