code: def _set_cached_solve(self, solver_dict):
          
          if self.status_ != ResolverStatus.solved:
              return  # don't cache failed solves
  
          if not (self.caching and self.memcached_servers):
              return
  
          # most recent release times get stored with solve result in the cache
          releases_since_solve = False
          release_times_dict = {}
          variant_states_dict = {}
  
          for variant in self.resolved_packages_:
              time_ = get_last_release_time(variant.name, self.package_paths)
  
              # don't cache if a release time isn't known
              if time_ == 0:
                  self._print("Did not send memcache key: a repository could "
                              "not provide a most recent release time for %r",
                              variant.name)
                  return
  
              if self.timestamp and self.timestamp < time_:
                  releases_since_solve = True
  
              release_times_dict[variant.name] = time_
              repo = variant.resource._repository
              variant_states_dict[variant.name] = \
                  repo.get_variant_state_handle(variant.resource)
  
          timestamped = (self.timestamp and releases_since_solve)
          key = self._memcache_key(timestamped=timestamped)
          data = (solver_dict, release_times_dict, variant_states_dict)
          with self._memcached_client() as client:
              client.set(key, data)
          self._print("Sent memcache key: %r", key)
docs: Store a solve to memcached.
  
          If there is NOT a resolve timestamp:
              - store the solve to a non-timestamped entry.
  
          If there IS a resolve timestamp (let us call this T):
              - if NO newer package in the solve has been released since T,
                - then store the solve to a non-timestamped entry;
              - else:
                - store the solve to a timestamped entry.