docs: def _update_marshallers(self):
          """ Update the full marshaller list and other data structures.
  
          Makes a full list of both builtin and user marshallers and
          rebuilds internal data structures used for looking up which
          marshaller to use for reading/writing Python objects to/from
          file.
  
          Also checks for whether the required modules are present or not,
          loading the required modules (if not doing lazy loading), and
          whether the required modules are imported already or not.
  
          """
          # Combine all sets of marshallers.
          self._marshallers = []
          for v in self._priority:
              if v == 'builtin':
                  self._marshallers.extend(self._builtin_marshallers)
              elif v == 'plugin':
                  self._marshallers.extend(self._plugin_marshallers)
              elif v == 'user':
                  self._marshallers.extend(self._user_marshallers)
              else:
                  raise ValueError('priority attribute has an illegal '
                                   'element value.')
  
          # Determine whether the required modules are present, do module
          # loading, and determine whether the required modules are
          # imported.
          self._has_required_modules = len(self._marshallers) * [False]
          self._imported_required_modules = \
              len(self._marshallers) * [False]
  
          for i, m in enumerate(self._marshallers):
              # Check if the required modules are here.
              try:
                  for name in m.required_parent_modules:
                      if name not in sys.modules \
                              and pkgutil.find_loader(name) is None:
                          raise ImportError('module not present')
              except ImportError:
                  self._has_required_modules[i] = False
              except:
                  raise
              else:
                  self._has_required_modules[i] = True
  
              # Modules obviously can't be fully loaded if not all are
              # present.
              if not self._has_required_modules[i]:
                  self._imported_required_modules[i] = False
                  continue
  
              # Check if all modules are loaded or not, and load them if
              # doing lazy loading.
              try:
                  for name in m.required_modules:
                      if name not in sys.modules:
                          raise ImportError('module not loaded yet.')
              except ImportError:
                  if self._lazy_loading:
                      self._imported_required_modules[i] = False
                  else:
                      success = self._import_marshaller_modules(m)
                      self._has_required_modules[i] = success
                      self._imported_required_modules[i] = success
              except:
                  raise
              else:
                  self._imported_required_modules[i] = True
  
          # Construct the dictionary to look up the appropriate marshaller
          # by type, the equivalent one to read data types given type
          # strings needs to be created from it (basically, we have to
          # make the key be the python_type_string from it), and the
          # equivalent one to read data types given MATLAB class strings
          # needs to be created from it (basically, we have to make the
          # key be the matlab_class from it).
          #
          # Marshallers earlier in the list have priority (means that the
          # builtins have the highest). Since the types can be specified
          # as strings as well, duplicates will be checked for by running
          # each type through str if it isn't str.
          types_as_str = set()
          self._types = dict()
          self._type_strings = dict()
          self._matlab_classes = dict()
          for i, m in enumerate(self._marshallers):
              # types.
              for tp in m.types:
                  if isinstance(tp, str):
                      tp_as_str = tp
                  else:
                      tp_as_str = tp.__module__ + '.' + tp.__name__
                  if tp_as_str not in types_as_str:
                      self._types[tp_as_str] = i
                      types_as_str.add(tp_as_str)
              # type strings
              for type_string in m.python_type_strings:
                  if type_string not in self._type_strings:
                      self._type_strings[type_string] = i
              # matlab classes.
              for matlab_class in m.matlab_classes:
                  if matlab_class not in self._matlab_classes:
                      self._matlab_classes[matlab_class] = i