note description: "[ Object that is use in relation with WSF_ROUTER, to precise which request methods is accepted. For convenience, `make_from_iterable' is available, so that you can use <<"GET", "POST">> for instance but remember manifest string are evil ... Since in HTTP you can use your own custom request method, this is not possible to catch any typo ( for instance if you write "POST" instead of "P0ST" this is hard to find the error, but in one case it uses upper "o" and in the other case this is zero "0" ) The recommanded way to use is for instance create {WSF_REQUEST_METHODS}.make_get_post create methods; methods.enable_get; methods.enable_post This sounds heavy, but this is much safer. ( note: in addition internally this first checks using reference comparison and then compare string value, so it brings optimization for accepted request methods. ) ]" date: "$Date$" revision: "$Revision$" class WSF_REQUEST_METHODS inherit ITERABLE [READABLE_STRING_8] redefine default_create end HTTP_REQUEST_METHODS redefine default_create end create default_create, make, make_from_iterable, make_from_string convert to_array: {ARRAY [READABLE_STRING_8]}, make_from_iterable ({ITERABLE [READABLE_STRING_8], ITERABLE [STRING_8], ARRAY [READABLE_STRING_8], ARRAY [STRING_8]}), make_from_string ({READABLE_STRING_8, STRING_8}) feature {NONE} -- Initialization default_create do Precursor make (1) end make (n: INTEGER) -- Initialize with capacity for `n' methods. require valid_number_of_items: n >= 0 do create methods.make (n) end make_from_iterable (v: ITERABLE [READABLE_STRING_8]) -- Initialize for all methods named by `v'. require v_all_methods_attached: v /= Void and then across v as c all c.item /= Void end do make (1) add_methods (v) end make_from_string (v: READABLE_STRING_8) -- Initialize from comma-separated methods named in `v'. require v_attached: v /= Void do make_from_iterable (v.split (',')) end feature -- Status report is_locked: BOOLEAN -- Is Current locked? And then can not be modified? is_empty: BOOLEAN do Result := methods.count = 0 end has (a_method: READABLE_STRING_8): BOOLEAN -- Has `a_method' enabled? require a_method_attached: a_method /= Void a_method_is_uppercase: a_method.same_string (a_method.as_upper) do -- First look for string object itself, -- in case `a_method' comes from one of the HTTP_REQUEST_METHODS constants Result := across methods as c some c.item = a_method end if not Result then -- If not found, look for the same string value Result := across methods as c some c.item.same_string_general (a_method) end end end has_some_of (a_methods: WSF_REQUEST_METHODS): BOOLEAN -- Have any methods from `a_methods' been enabled? require a_methods_attached: a_methods /= Void do Result := across a_methods as c some has (c.item) end end has_all_of (a_methods: WSF_REQUEST_METHODS): BOOLEAN -- Have all methods from `a_methods' been enabled? require a_methods_attached: a_methods /= Void do Result := across a_methods as c all has (c.item) end end has_method_get: BOOLEAN -- Has method GET been enabled? do Result := has (method_get) end has_method_post: BOOLEAN -- Has method POST been enabled? do Result := has (method_post) end has_method_put: BOOLEAN -- Has method PUT been enabled? do Result := has (method_put) end has_method_delete: BOOLEAN -- Has method DELETE been enabled? do Result := has (method_delete) end has_method_options: BOOLEAN -- Has method OPTIONS been enabled? do Result := has (method_options) end has_method_head: BOOLEAN -- Has method HEAD been enabled? do Result := has (method_head) end has_method_trace: BOOLEAN -- Has method TRACE been enabled? do Result := has (method_trace) end has_method_connect: BOOLEAN -- Has method CONNECT been enabled? do Result := has (method_connect) end has_method_patch: BOOLEAN -- Has method PATCH been enabled? do Result := has (method_patch) end feature -- Access new_cursor: INDEXABLE_ITERATION_CURSOR [READABLE_STRING_8] -- Fresh cursor associated with current structure do Result := methods.new_cursor end feature -- Status change lock -- Lock current and prevent any change in methods -- Once it is locked, it is impossible to unlock. do is_locked := True end feature -- Basic operations plus alias "+" (a_other: WSF_REQUEST_METHODS): WSF_REQUEST_METHODS -- Merge Current and a_other into Result require a_other_not_void: a_other /= Void do create Result.make_from_iterable (Current) Result.add_methods (a_other) end feature -- Element change enable_get require is_not_locked: not is_locked get_disabled: not has (method_get) do methods.extend (method_get) ensure get_enabled: has (method_get) end disable_get require is_not_locked: not is_locked get_enabled: has (method_get) do prune_method (method_get) ensure get_disabled: not has (method_get) end enable_post require is_not_locked: not is_locked post_disabled: not has (method_post) do methods.extend (method_post) ensure post_enabled: has (method_post) end disable_post require is_not_locked: not is_locked post_enabled: has (method_post) do prune_method (method_post) ensure post_disabled: not has (method_post) end enable_put require is_not_locked: not is_locked put_disabled: not has (method_put) do methods.extend (method_put) ensure put_enabled: has (method_put) end disable_put require is_not_locked: not is_locked put_enabled: has (method_put) do prune_method (method_put) ensure put_disabled: not has (method_put) end enable_delete require is_not_locked: not is_locked delete_disabled: not has (method_delete) do methods.extend (method_delete) ensure delete_enabled: has (method_delete) end disable_delete require is_not_locked: not is_locked delete_enabled: has (method_delete) do prune_method (method_delete) ensure delete_disabled: not has (method_delete) end enable_options require is_not_locked: not is_locked options_disabled: not has (method_options) do methods.extend (method_options) ensure options_enabled: has (method_options) end disable_options require is_not_locked: not is_locked options_enabled: has (method_options) do prune_method (method_options) ensure options_disabled: not has (method_options) end enable_head require is_not_locked: not is_locked head_disabled: not has (method_head) do methods.extend (method_head) ensure head_enabled: has (method_head) end disable_head require is_not_locked: not is_locked head_enabled: has (method_head) do prune_method (method_head) ensure head_disabled: not has (method_head) end enable_trace require is_not_locked: not is_locked trace_disabled: not has (method_trace) do methods.extend (method_trace) ensure trace_enabled: has (method_trace) end disable_trace require is_not_locked: not is_locked trace_enabled: has (method_trace) do prune_method (method_trace) ensure trace_disabled: not has (method_trace) end enable_connect require is_not_locked: not is_locked connect_disabled: not has (method_connect) do methods.extend (method_connect) ensure connect_enabled: has (method_connect) end disable_connect require is_not_locked: not is_locked connect_enabled: has (method_connect) do prune_method (method_connect) ensure connect_disabled: not has (method_connect) end enable_patch require is_not_locked: not is_locked patch_disabled: not has (method_patch) do methods.extend (method_patch) ensure patch_enabled: has (method_patch) end disable_patch require is_not_locked: not is_locked patch_enabled: has (method_patch) do prune_method (method_patch) ensure patch_disabled: not has (method_patch) end enable_custom (m: READABLE_STRING_8) require is_not_locked: not is_locked not_blank: not across m as mc some mc.item.is_space end custom_disabled: not has (m.as_upper) do methods.extend (m.as_upper) ensure custom_enabled: has (m.as_upper) end disable_custom (m: READABLE_STRING_8) require is_not_locked: not is_locked m_attached: m /= Void not_blank: not across m as mc some mc.item.is_space end custom_enabled: has (m.as_upper) do prune_method (m.as_upper) ensure custom_disabled: not has (m.as_upper) end feature -- Access methods: ARRAYED_LIST [READABLE_STRING_8] to_array: ARRAY [READABLE_STRING_8] do Result := methods.to_array end feature {WSF_REQUEST_METHODS} -- Implementation add_methods (lst: ITERABLE [READABLE_STRING_8]) -- Enable methods from `lst'. require lst_all_attached: lst /= Void and then across lst as c all c.item /= Void end do if not is_locked then across lst as c loop if not c.item.is_empty and not has (c.item) then add_method_using_constant (c.item) end end end end feature {NONE} -- Implementation add_method_using_constant (v: READABLE_STRING_8) -- Add method `v' using method_* constant. require v_attached: v /= Void v_not_empty: not v.is_empty new_method: not has (v) do if v.is_case_insensitive_equal (method_get) then enable_get elseif v.is_case_insensitive_equal (method_post) then enable_post elseif v.is_case_insensitive_equal (method_put) then enable_put elseif v.is_case_insensitive_equal (method_delete) then enable_delete elseif v.is_case_insensitive_equal (method_head) then enable_head elseif v.is_case_insensitive_equal (method_options) then enable_options elseif v.is_case_insensitive_equal (method_trace) then enable_trace elseif v.is_case_insensitive_equal (method_connect) then enable_connect elseif v.is_case_insensitive_equal (method_patch) then enable_patch else enable_custom (v) end ensure method_set: has (v.as_upper) end prune_method (v: READABLE_STRING_8) -- Remove method named `v' from `Current'. -- Does nothing if `Current' `is_locked'. require v_attached: v /= Void is_upper_case: v.same_string (v.as_upper) local m: READABLE_STRING_8 do if not is_locked then from methods.start until methods.after loop m := methods.item if m = v or else m.same_string (v) then methods.remove else methods.forth end end end end invariant methods_attached: methods /= Void methods_are_uppercase: across methods as c all c.item.same_string (c.item.as_upper) end ;note copyright: "2011-2013, Jocelyn Fiat, Javier Velilla, Olivier Ligot, Eiffel Software and others" license: "Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)" source: "[ Eiffel Software 5949 Hollister Ave., Goleta, CA 93117 USA Telephone 805-685-1006, Fax 805-685-6869 Website http://www.eiffel.com Customer support http://support.eiffel.com ]" end