          """
          self._stream = stream
  
  
      def _get_raw_content(self):
          """
          Returns the parsed content of the request
          """
          if not hasattr(self, '_raw_content'):
              self._raw_content = self.parse(self.stream, self.content_type)
          return self._raw_content
  
  
      def _get_content(self):
          """
          Returns the parsed and validated content of the request
 
</s> remove         if self.CONTENT_PARAM in content and self.CONTENTTYPE_PARAM in content:
            self._content_type = content[self.CONTENTTYPE_PARAM]
            self._stream = StringIO(content[self.CONTENT_PARAM])
            del(self._raw_content)
 </s> add         if self._CONTENT_PARAM in content and self._CONTENTTYPE_PARAM in content:
            self._content_type = content[self._CONTENTTYPE_PARAM]
            self._stream = StringIO(content[self._CONTENT_PARAM])
            del(self._data) </s> remove     @classmethod
    def object_to_serializable(self, data):
        """A (horrible) munging of Piston's pre-serialization.  Returns a dict"""
 </s> add     # TODO: Replace this with new Serializer code based on Forms API.
    def object_to_data(self, obj):
        """
        A (horrible) munging of Piston's pre-serialization.  Returns a dict.
        """ </s> remove # TODO: Replace this with new Serializer code based on Forms API.
 </s> add def _form_to_data(form):
    """
    Returns a dict containing the data in a form instance.
    
    This code is pretty much a clone of the ``Form.as_p()`` ``Form.as_ul``
    and ``Form.as_table()`` methods, except that it returns data suitable
    for arbitrary serialization, rather than rendering the result directly
    into html.
    """
    ret = {}
    for name, field in form.fields.items():
        if not form.is_bound:
            data = form.initial.get(name, field.initial)
            if callable(data):
                data = data()
        else:
            if isinstance(field, FileField) and form.data is None:
                data = form.initial.get(name, field.initial)
            else:
                data = field.widget.value_from_datadict(form.data, form.files, name)
        ret[name] = field.prepare_value(data)
    return ret </s> remove     # TODO: Acutally this needs to go into Resource
    def validate(self, content):
        """
        Validate, cleanup, and type-ify the request content.
        """
        for validator_cls in self.validators:
            validator = validator_cls(self)
            content = validator.validate(content)
        return content


    # TODO: Acutally this needs to go into Resource
    def get_bound_form(self, content=None):
        """
        Return a bound form instance for the given content,
        if there is an appropriate form validator attached to the view.
        """
        for validator_cls in self.validators:
            if hasattr(validator_cls, 'get_bound_form'):
                validator = validator_cls(self)
                return validator.get_bound_form(content)
        return None


 </s> add 
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
          """
          self._stream = stream
  
  
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
    def _load_data_and_files(self):
        (self._data, self._files) = self._parse(self.stream, self.content_type)
  
  
      def _get_content(self):
          """
          Returns the parsed and validated content of the request
keep keep keep keep replace replace replace replace replace replace replace keep keep keep keep keep
 refactoring resource specfic stuff into ResourceMixin - validators now defunct 
djangorestframework/mixins.py