docs: def xross_view(*op_functions):
      """This decorator should be used to decorate application views that require xross functionality.
  
      :param list op_functions: operations (functions, methods) responsible for handling xross requests.
  
          Function names considered to be operations names. Using them clients will address those functions
          (e.g. xross-ready HTML elements may be marked with `data-xop` attributes to define
          the above mentioned operations, or just define `id` which will serve for the same purpose).
  
          They can accept `request` as first argument (for methods it'll be second, as the first is `self`),
          and other params from client side (e.g. defined in `data-x...` html element attributes).
  
          It can also accept `xross` keyword argument, which will contain any additional `xross attrs`
          as defined by `xross_listener()`.
  
          Those functions should return string or dict (handled by client as JSON) or HTTPResponse,
          e.g. from `render()` result.
  
          Examples:
  
              def do_something(request, param1_from_html_el, param2_from_html_el, xross=None):
                  return '%s - %s' % (param1_from_html_el, param2_from_html_el)
  
      """
  
      operations_dict = construct_operations_dict(*op_functions)
  
      def get_request(src):
          return src if isinstance(src, HttpRequest) else None
  
      def dec_wrapper(func):
          def func_wrapper(*fargs, **fkwargs):
  
              request_idx = getattr(func, '_req_idx', None)
              if request_idx is None:
                  request = get_request(fargs[0])
                  request_idx = 0
                  if not request:
                      # Possibly a class-based view where 0-attr is `self`.
                      request = get_request(fargs[1])
                      request_idx = 1
                  func._req_idx = request_idx
  
              else:
                  request = fargs[request_idx]
  
              if hasattr(request, '_xross_handler'):
                  request._xross_handler._op_bindings.update(operations_dict['_op_bindings'])
              else:
                  request._xross_handler = build_handler_class(operations_dict)(request, func)
  
              try:
                  response = func(*fargs, **fkwargs)
  
              except HandlerException as e:
                  return HttpResponseBadRequest(e if settings.DEBUG else b'')
  
              except ResponseEmpty as e:
                  return HttpResponseNotFound(e if settings.DEBUG else b'')
  
              except ResponseReady as r:
                  response = r.response
  
                  if response is None:
                      response = ''
  
                  if isinstance(response, str):
                      response = HttpResponse(response)
  
                  elif isinstance(response, dict):
                      response = HttpResponse(json.dumps(response), content_type='application/json')
  
              return response
  
          return func_wrapper
      return dec_wrapper