code: def write(self, file_path=None, ignore_extension_data=False):
          
          # make sure we have our entries read before getting a write lock
          # else it would be done when streaming. This can happen
          # if one doesn't change the index, but writes it right away
          self.entries
          lfd = LockedFD(file_path or self._file_path)
          stream = lfd.open(write=True, stream=True)
  
          ok = False
          try:
              self._serialize(stream, ignore_extension_data)
              ok = True
          finally:
              if not ok:
                  lfd.rollback()
  
          lfd.commit()
  
          # make sure we represent what we have written
          if file_path is not None:
              self._file_path = file_path
docs: Write the current state to our file path or to the given one
  
          :param file_path:
              If None, we will write to our stored file path from which we have
              been initialized. Otherwise we write to the given file path.
              Please note that this will change the file_path of this index to
              the one you gave.
  
          :param ignore_extension_data:
              If True, the TREE type extension data read in the index will not
              be written to disk. NOTE that no extension data is actually written.
              Use this if you have altered the index and
              would like to use git-write-tree afterwards to create a tree
              representing your written changes.
              If this data is present in the written index, git-write-tree
              will instead write the stored/cached tree.
              Alternatively, use IndexFile.write_tree() to handle this case
              automatically
  
          :return: self