class HTTPX::Options

    # File lib/httpx/options.rb
233 def ==(other)
234   super || options_equals?(other)
235 end

    # File lib/httpx/options.rb
302 def extend_with_plugin_classes(pl)
303   if defined?(pl::RequestMethods) || defined?(pl::RequestClassMethods)
304     @request_class = @request_class.dup
305     @request_class.__send__(:include, pl::RequestMethods) if defined?(pl::RequestMethods)
306     @request_class.extend(pl::RequestClassMethods) if defined?(pl::RequestClassMethods)
307   end
308   if defined?(pl::ResponseMethods) || defined?(pl::ResponseClassMethods)
309     @response_class = @response_class.dup
310     @response_class.__send__(:include, pl::ResponseMethods) if defined?(pl::ResponseMethods)
311     @response_class.extend(pl::ResponseClassMethods) if defined?(pl::ResponseClassMethods)
312   end
313   if defined?(pl::HeadersMethods) || defined?(pl::HeadersClassMethods)
314     @headers_class = @headers_class.dup
315     @headers_class.__send__(:include, pl::HeadersMethods) if defined?(pl::HeadersMethods)
316     @headers_class.extend(pl::HeadersClassMethods) if defined?(pl::HeadersClassMethods)
317   end
318   if defined?(pl::RequestBodyMethods) || defined?(pl::RequestBodyClassMethods)
319     @request_body_class = @request_body_class.dup
320     @request_body_class.__send__(:include, pl::RequestBodyMethods) if defined?(pl::RequestBodyMethods)
321     @request_body_class.extend(pl::RequestBodyClassMethods) if defined?(pl::RequestBodyClassMethods)
322   end
323   if defined?(pl::ResponseBodyMethods) || defined?(pl::ResponseBodyClassMethods)
324     @response_body_class = @response_body_class.dup
325     @response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
326     @response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
327   end
328   if defined?(pl::ConnectionMethods)
329     @connection_class = @connection_class.dup
330     @connection_class.__send__(:include, pl::ConnectionMethods)
331   end
332   return unless defined?(pl::OptionsMethods)
333 
334   @options_class = @options_class.dup
335   @options_class.__send__(:include, pl::OptionsMethods)
336 end

    # File lib/httpx/options.rb
138 def freeze
139   super
140   @origin.freeze
141   @base_path.freeze
142   @timeout.freeze
143   @headers.freeze
144   @addresses.freeze
145   @supported_compression_formats.freeze
146 end

    # File lib/httpx/options.rb
260 def merge(other)
261   ivar_map = nil
262   other_ivars = case other
263                 when Hash
264                   ivar_map = other.keys.to_h { |k| [:"@#{k}", k] }
265                   ivar_map.keys
266                 else
267                   other.instance_variables
268   end
269 
270   return self if other_ivars.empty?
271 
272   return self if other_ivars.all? { |ivar| instance_variable_get(ivar) == OTHER_LOOKUP[other, ivar, ivar_map] }
273 
274   opts = dup
275 
276   other_ivars.each do |ivar|
277     v = OTHER_LOOKUP[other, ivar, ivar_map]
278 
279     unless v
280       opts.instance_variable_set(ivar, v)
281       next
282     end
283 
284     v = opts.__send__(:"option_#{ivar[1..-1]}", v)
285 
286     orig_v = instance_variable_get(ivar)
287 
288     v = orig_v.merge(v) if orig_v.respond_to?(:merge) && v.respond_to?(:merge)
289 
290     opts.instance_variable_set(ivar, v)
291   end
292 
293   opts
294 end

    # File lib/httpx/options.rb
210 def option_addresses(value)
211   Array(value)
212 end

    # File lib/httpx/options.rb
152 def option_base_path(value)
153   String(value)
154 end

    # File lib/httpx/options.rb
196 def option_body_threshold_size(value)
197   bytes = Integer(value)
198   raise TypeError, ":body_threshold_size must be positive" unless bytes.positive?
199 
200   bytes
201 end

    # File lib/httpx/options.rb
188 def option_buffer_size(value)
189   value = Integer(value)
190 
191   raise TypeError, ":buffer_size must be positive" unless value.positive?
192 
193   value
194 end

    # File lib/httpx/options.rb
156 def option_headers(value)
157   headers_class.new(value)
158 end

    # File lib/httpx/options.rb
214 def option_ip_families(value)
215   Array(value)
216 end

    # File lib/httpx/options.rb
168 def option_max_concurrent_requests(value)
169   raise TypeError, ":max_concurrent_requests must be positive" unless value.positive?
170 
171   value
172 end

    # File lib/httpx/options.rb
174 def option_max_requests(value)
175   raise TypeError, ":max_requests must be positive" unless value.positive?
176 
177   value
178 end

    # File lib/httpx/options.rb
148 def option_origin(value)
149   URI(value)
150 end

    # File lib/httpx/options.rb
164 def option_supported_compression_formats(value)
165   Array(value).map(&:to_s)
166 end

    # File lib/httpx/options.rb
160 def option_timeout(value)
161   Hash[value]
162 end

    # File lib/httpx/options.rb
203 def option_transport(value)
204   transport = value.to_s
205   raise TypeError, "#{transport} is an unsupported transport type" unless %w[unix].include?(transport)
206 
207   transport
208 end

    # File lib/httpx/options.rb
180 def option_window_size(value)
181   value = Integer(value)
182 
183   raise TypeError, ":window_size must be positive" unless value.positive?
184 
185   value
186 end

    # File lib/httpx/options.rb
237 def options_equals?(other, ignore_ivars = REQUEST_BODY_IVARS)
238   # headers and other request options do not play a role, as they are
239   # relevant only for the request.
240   ivars = instance_variables - ignore_ivars
241   other_ivars = other.instance_variables - ignore_ivars
242 
243   return false if ivars.size != other_ivars.size
244 
245   return false if ivars.sort != other_ivars.sort
246 
247   ivars.all? do |ivar|
248     instance_variable_get(ivar) == other.instance_variable_get(ivar)
249   end
250 end

    # File lib/httpx/options.rb
296 def to_hash
297   instance_variables.each_with_object({}) do |ivar, hs|
298     hs[ivar[1..-1].to_sym] = instance_variable_get(ivar)
299   end
300 end