docs: def register(self, cls, parameters=None,overwrite = False):
          """
          Explicitly register a new document class for use in the backend.
  
          :param cls:        A reference to the class to be defined
          :param parameters: A dictionary of parameters. Currently, only the `collection` parameter is used
                             to specify the collection in which to store the documents of the given class.
  
          .. admonition:: Registering classes
  
              If possible, always use `autodiscover_classes = True` or register your document classes beforehand
              using the `register` function, since this ensures that related documents can be initialized
              appropriately. For example, suppose you have a document class `Author` that contains a list of
              references to documents of class `Book`. If you retrieve an instance of an `Author` object from
              the database without having registered the `Book` class, the references to that class will not get
              parsed properly and will just show up as dictionaries containing a primary key and a collection name.
  
              Also, when :py:meth:`blitzdb.backends.base.Backend.autoregister` is used to register a class,
              you can't pass in any parameters to customize e.g. the collection name for that class
              (you can of course do this throught the `Meta` attribute of the class)
  
          ## Inheritance
  
          If `register` encounters a document class with a collection name that overlaps with the
          collection name of an already registered document class, it checks if the new class is a
          subclass of the one that is already register. If yes, it associates the new class to the
          collection name. Otherwise, it leaves the collection associated to the already
          registered class.
          """
  
          if cls in self.deprecated_classes and not overwrite:
              return False
  
          if parameters is None:
              parameters = {}
          if 'collection' in parameters:
              collection_name = parameters['collection']
          elif hasattr(cls.Meta,'collection'):
              collection_name = cls.Meta.collection
          else:
              collection_name = cls.__name__.lower()
  
          delete_list = []
  
          def register_class(collection_name,cls):
              self.collections[collection_name] = cls
              self.classes[cls] = parameters.copy()
              self.classes[cls]['collection'] = collection_name
  
          if collection_name in self.collections:
              old_cls = self.collections[collection_name]
              if (issubclass(cls,old_cls) and not (cls is old_cls)) or overwrite:
                  logger.warning("Replacing class %s with %s for collection %s" % (old_cls,cls,collection_name))
                  self.deprecated_classes[old_cls] = self.classes[old_cls]
                  del self.classes[old_cls]
                  register_class(collection_name,cls)
                  return True
          else:
              logger.debug("Registering class %s under collection %s" % (cls,collection_name))
              register_class(collection_name,cls)
              return True
  
          return False