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

class
	O_SERVICE_ADVERTISEMENT

inherit
	P2P_ADVERTISEMENT
		redefine
			initialize,
			document,
			validate
		end

create
	make,
	make_from_element,
	parse_from_string

feature {NONE} -- Initialization

	make (a_type: like type; a_name: like name; a_list: like roles) is
			-- Create new Origo service configuration advertisement
		require
			Type_valid: a_type >= 0
			Name_valid: a_name /= Void and not a_name.is_empty
			List_valid: a_list /= Void and a_list.count > 0
		do
			initialize
			set_type (a_type)
			set_name (a_name)
			set_role_list (a_list)

			is_valid := True
		ensure
			Type_set: type = a_type
			Name_set: name.is_equal (a_name)
			List_set: roles.count = a_list.count
		end

feature -- Access

	type: INTEGER
	name: STRING
	description: STRING
	additional_info: STRING
	roles: DS_LIST [STRING]

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

	unique_id: STRING is
			-- Unique id
		do
			Result := "OrigoServiceAdvertisement/" + type.out + "/" + 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_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_description.is_equal (an_element_name) then
				Result := does_element_match (description, an_element_value)
			elseif element_additional_info.is_equal (an_element_name) then
				Result := does_element_match (additional_info, an_element_value)
			elseif element_role.is_equal (an_element_name) then
				Result := roles.has (an_element_value)
			end
		end

feature -- Element change

	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_description (a_description: like description) is
			-- Set new description
		require
			description_valid: a_description /= Void and not a_description.is_empty
		do
			description := a_description
			renew_document
		ensure
			description_set: description.is_equal (a_description)
		end

	set_additional_info (an_additional_info: like additional_info) is
			-- Set new additional info
		require
			Info_valid: an_additional_info /= Void and not an_additional_info.is_empty
		do
			additional_info := an_additional_info
			renew_document
		ensure
			Info_set: additional_info.is_equal (an_additional_info)
		end

	add_role (a_role: STRING) is
			-- Add new role
		require
			Role_valid: a_role /= Void and not a_role.is_empty
		do
			if not roles.has (a_role) then
				roles.put_last (a_role)
				renew_document
			end
		ensure
			Role_set: roles.has (a_role)
		end

	set_role_list (a_list: like roles) is
			-- Set role list
		require
			List_valid: a_list /= Void and a_list.count > 0
		do
			create {DS_LINKED_LIST [STRING]} roles.make_from_linear (a_list)
			renew_document
		ensure
			List_set: roles.count = a_list.count
		end

feature -- Removal

	prune_role (a_role: STRING) is
			-- Remove role
		require
			Role_valid: roles.has (a_role)
		do
			roles.start
			roles.search_forth (a_role)
			if not roles.after then
				roles.remove_at
				renew_document
			end
		ensure
			Role_pruned: not roles.has (a_role)
		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 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 Desc
				if description /= Void then
					Result.create_root_child_element (element_description, Result.namespace_empty)
					Result.create_content (Result.last_element, description)
				end
				-- element AInf
				if additional_info /= Void then
					Result.create_root_child_element (element_additional_info, Result.namespace_empty)
					Result.create_content (Result.last_element, additional_info)
				end
				from
					roles.start
				until
					roles.after
				loop
					-- element Role
					Result.create_root_child_element (element_role, Result.namespace_empty)
					Result.create_content (Result.last_element, roles.item_for_iteration)
					roles.forth
				end
			end
		end

feature {NONE} -- Implementation

	Element_type: STRING is "Type"
	Element_name: STRING is "Name"
	Element_description: STRING is "Desc"
	Element_additional_info: STRING is "AInf"
	Element_role: STRING is "Role"

	root_element_name: STRING is "OrigoService"

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed advertisement
		local
			value: STRING
		do
			if 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_description.is_equal (element.name) then
				description := trimmed (element.text)
			elseif element_additional_info.is_equal (element.name) then
				additional_info := trimmed (element.text)
			elseif element_role.is_equal (element.name) then
				value := element_text (element)
				if not value.is_empty then
					roles.put_last (value)
				end
			end
		end

	validate is
			-- Validate advertisement and set `is_valid'
		do
			is_valid := is_valid and type >= 0 and name /= Void and not name.is_empty and roles.count > 0
		end

	initialize is
			-- Initialize object's data structure
		local
			equality_tester: KL_EQUALITY_TESTER [STRING]
		do
			Precursor
			create {DS_LINKED_LIST [STRING]} roles.make
			create equality_tester
			roles.set_equality_tester (equality_tester)
		end

invariant
	Roles_set: roles /= Void and roles.equality_tester /= Void

end