Equivalent to load_target! except that any options that were passed
 to load_target! the last time it was called will be re-applied when
 (re)loading the target.
16661
def reload_target!(options = {})
      old_options = @target_load_options || {}
      options = (@target_load_options || {}).merge(options)
      if options[:skip_first_time] && @target_load_count == 1
        @target_load_count += 1
      else
        load_target!(options.merge(reload: true))
      end
    end
396981
def replace(self, target):
        
        if sys.version_info < (3, 3):
            raise NotImplementedError("replace() is only available "
                                      "with Python 3.3 and later")
        if self._closed:
            self._raise_closed()
        self._accessor.replace(self, target)
762863
def reload(self):
        

        if not self.fd.closed: self.fd.close()

        self.fd = open(self.fd.name, 'r')
        self.load()
1045134
def rename(self, target):
        
        if self._closed:
            self._raise_closed()
        self._accessor.rename(self, target)
497182
def reload(options = nil)
      clear_aggregation_cache
      clear_association_cache

      IdentityMap.without do
        fresh_object = self.class.unscoped { self.class.find(self.id, options) }
        @attributes.update(fresh_object.instance_variable_get('@attributes'))
      end

      @attributes_cache = {}
      self
    end
105714
def reload(self):
        
        new = self.__class__.pickle_load(self.workdir)
        self = new
588779
def load_app(target):
    
    global NORUN
    NORUN, nr_old = True, NORUN
    tmp = default_app.push()  # Create a new "default application"
    try:
        rv = load(target)  # Import the target module
        return rv if callable(rv) else tmp
    finally:
        default_app.remove(tmp)  # Remove the temporary added default application
        NORUN = nr_old
480604
def reload(self):
        
        text = self._read(self.location)
        cursor_position = min(self.buffer.cursor_position, len(text))

        self.buffer.document = Document(text, cursor_position)
        self._file_content = text
4690
def load_target
      target = super
      return unless target
      return target if inversed

      time = owner.logidze_requested_ts

      if target.is_a? Array
        target.map! do |object|
          object.at(time: time)
        end.compact!
      else
        target.at!(time: time)
      end

      target
    end
1092826
def mark_module_reloadable(self, module_name):
        """"""
        try:
            del self.skip_modules[module_name]
        except KeyError:
            pass
        self.modules[module_name] = True
1016206
def reload(self):
        
        realData = self.load()
        self.clear()
        self.update(realData)
247754
def reload(self):
        
        instance_pb = self._client.instance_admin_client.get_instance(self.name)

        # NOTE: _update_from_pb does not check that the project and
        #       instance ID on the response match the request.
        self._update_from_pb(instance_pb)
397568
def load(self, executable):
        
        if self.status == 'loaded':
            warnings.warn("Overwriting previously loaded executable.")
        assert self.status in ['connected', 'done', 'loaded']

        self._variables_shim = {}
        self._executable = executable
        self._bitstrings = None
        self.status = 'loaded'
        return self
283392
def reload_source(self, name, init_source=True):
        """"""

        for c in self.components:
            c.reload_source(name)

        if init_source:
            self._init_source(name)

        self.like.model = self.like.components[0].model
883575
public static synchronized void reload() {
    map = new HashMap<Class<?>, Object>();
    customProperties = loadFile(CUSTOM_TUNING_FILE_NAME);
    defaultProperties = loadFile(DEFAULT_TUNING_FILE_NAME);
  }
184607
def load(**options):
    
    log.msg("Hello!, I am a dummy, so I won't do a thing!")
    if len(options):
        log.msg_debug("I have received a bunch of options, here they come ...")
        for o, v in options.items():
            log.msg_debug("Option: name={name}, value={value}"
                          .format(name=o, value=v))
836570
def reload(self, result=None):
        

        if result is None:
            result = self._client._get(
                self.__class__.base_url(
                    self.sys['space'].id,
                    self.sys['id'],
                    environment_id=self._environment_id
                )
            )

        self._update_from_resource(result)

        return self