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

class
	P2P_GENERIC_SRDI

inherit
	P2P_XML_CACHE
		redefine
			initialize,
			document,
			validate
		end

create
	make,
	make_from_element,
	parse_from_string

feature {NONE} -- Initialization

	make (a_peer_id: like peer_id; a_primary_key: like primary_key; a_ttl: like ttl; a_list: like entries) is
			-- Create new srdi payload
		require
			Peer_id_valid: a_peer_id /= Void and a_peer_id.is_valid
			Primary_key_valid: a_primary_key /= Void
			Ttl_valid: a_ttl >= 0
			Entries_valid: a_list /= Void and a_list.count > 0
		do
			initialize
			set_peer_id (a_peer_id)
			set_primary_key (a_primary_key)
			set_ttl (a_ttl)
			set_entries (a_list)
			is_valid := True
		ensure
			Peer_id_set: peer_id.is_equal (a_peer_id)
			Primary_key_set: primary_key.is_equal (a_primary_key)
			Ttl_set: ttl = a_ttl
			Entries_set: entries.count = a_list.count
		end

feature -- Access

	peer_id: P2P_PEER_ID
	primary_key: STRING
	ttl: INTEGER
	entries: DS_LIST [TUPLE [STRING, INTEGER_64, STRING]]

	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_primary_key.is_equal (an_element_name) then
				Result := does_element_match (primary_key, an_element_value)
			elseif element_ttl.is_equal (an_element_name) then
				Result := does_element_match (ttl, an_element_value)
			end
		end

feature -- Element change

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

	set_primary_key (a_primary_key: like primary_key) is
			-- Set primary key
		require
			Primary_key_valid: a_primary_key /= Void
		do
			primary_key := a_primary_key
			renew_document
		ensure
			Primary_key_set: primary_key.is_equal (a_primary_key)
		end

	set_ttl (a_ttl: like ttl) is
			-- Set ttl
		require
			Ttl_valid: a_ttl >= 0
		do
			ttl := a_ttl
			renew_document
		ensure
			Ttl_set: ttl = a_ttl
		end

	set_entries (a_list: like entries) is
			-- Set entries
		require
			List_valid: a_list /= Void and a_list.count > 0
		do
			create {DS_ARRAYED_LIST [TUPLE [STRING, INTEGER_64, STRING]]} entries.make_from_linear (a_list)
			renew_document
		ensure
			Entries_set: entries.count = a_list.count
		end

feature -- Output

	document: P2P_XML_DOCUMENT is
			-- Create XML document
		local
			cached: BOOLEAN
			skey, value: STRING
			expiration: INTEGER_64
		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 PKey
				Result.create_root_child_element (element_primary_key, Result.namespace_empty)
				Result.create_content (Result.last_element, primary_key)
				-- Element ttl
				Result.create_root_child_element (element_ttl, Result.namespace_empty)
				Result.create_content (Result.last_element, ttl.out)
				from
					entries.start
				until
					entries.after
				loop
					-- Element Entry
					skey ?= entries.item_for_iteration.item (index_secondary_key)
					expiration ?= entries.item_for_iteration.item (index_expiration)
					value ?= entries.item_for_iteration.item (index_value)
					Result.create_root_child_element (element_entry, Result.namespace_empty)
					Result.last_element.add_unqualified_attribute (attribute_secondary_key, skey)
					Result.last_element.add_unqualified_attribute (attribute_expiration, expiration.out)
					Result.create_content (Result.last_element, value)
					entries.forth
				end
			end
		end

feature {NONE} -- Implementation

	Element_peer_id: STRING is "PID"
	Element_primary_key: STRING is "PKey"
	Element_ttl: STRING is "ttl"
	Element_entry: STRING is "Entry"
	Attribute_secondary_key: STRING is "SKey"
	Attribute_expiration: STRING is "Expiration"

	root_element_name: STRING is "GenSRDI"

	Index_secondary_key: INTEGER is 1
	Index_expiration: INTEGER is 2
	Index_value: INTEGER is 3

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

	element_handler (element: XM_ELEMENT) is
			-- Handle root child element of parsed document
		local
			a_ttl, value: STRING
			skey, expiration: XM_ATTRIBUTE
		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_primary_key.is_equal (element.name) then
				primary_key := trimmed (element.text)
			elseif element_ttl.is_equal (element.name) then
				a_ttl := trimmed (element.text)
				if a_ttl.is_integer then
					ttl := a_ttl.to_integer
				end
			elseif element_entry.is_equal (element.name) then
				skey := element.attribute_by_name (attribute_secondary_key)
				expiration := element.attribute_by_name (attribute_expiration)
				value := element_text (element)
				if skey /= Void and expiration /= Void and not value.is_empty and
						not skey.value.is_empty and expiration.value.is_integer_64 then
					entries.put_last ([skey.value, expiration.value.to_integer_64, value])
				end
			end
		end

	validate is
			-- Validate message and set `is_valid'
		do
			is_valid := is_valid and peer_id /= Void and primary_key /= Void and entries.count > 0
		end

	initialize is
			-- Initialize data structure
		do
			create {DS_LINKED_LIST [TUPLE [STRING, INTEGER_64, STRING]]} entries.make
		end

invariant
	Entries_valid: entries /= Void

end