reset all executions in this sub graph
485809
private void reset(long globalModVersionOfFailover) {
		try {
			// reset all connected ExecutionVertexes
			final Collection<CoLocationGroup> colGroups = new HashSet<>();
			final long restartTimestamp = System.currentTimeMillis();

			for (ExecutionVertex ev : connectedExecutionVertexes) {
				CoLocationGroup cgroup = ev.getJobVertex().getCoLocationGroup();
				if (cgroup != null && !colGroups.contains(cgroup)){
					cgroup.resetConstraints();
					colGroups.add(cgroup);
				}

				ev.resetForNewExecution(restartTimestamp, globalModVersionOfFailover);
			}
			if (transitionState(JobStatus.CANCELED, JobStatus.CREATED)) {
				restart(globalModVersionOfFailover);
			}
			else {
				LOG.info("FailoverRegion {} switched from CANCELLING to CREATED fail, will fail this region again.", id);
				failover(globalModVersionOfFailover);
			}
		}
		catch (GlobalModVersionMismatch e) {
			// happens when a global recovery happens concurrently to the regional recovery
			// go back to a clean state
			state = JobStatus.RUNNING;
		}
		catch (Throwable e) {
			LOG.info("FailoverRegion {} reset fail, will failover again.", id);
			failover(globalModVersionOfFailover);
		}
	}
561417
def clear(self, keep_attrs=False):
        
        if not keep_attrs:
            for a in (self.graph_attr, self.node_attr, self.edge_attr):
                a.clear()
        del self.body[:]
1272730
def reset(self):
        """"""
        self.idx_chan.clear()
        if self.scene is not None:
            self.scene.clear()
        self.scene = None
444789
def clear(self):
        
        self.adj.clear()
        self.node.clear()
        self.graph.clear()
1294126
def reset(self):
        """"""
        self.__init__(self.alpha, self.beta1, self.beta2, self.epsilon)
281640
def reset(self):
    
    self._unionSDR = numpy.zeros(shape=(self._numInputs,))
    self._activeCellsHistory = []
575546
def reset(self):
        
        self.__matrix = np.array([])
        self.__networks = np.array([])
217916
def Reset(self):
    """"""
    self._displayed = 0
    self._currentpagelines = 0
    self._lastscroll = 1
    self._lines_to_show = self._cli_lines
950348
def _reset(self):
        """"""
        self._subscriber_thread = None
        self._must_stop = threading.Event()
        self._number_periodic_tasks = 0
759889
def reset(self):
        
        for _, item in self.iter_items(recursive=True):
            item.reset()
498038
def reset(self):
        
        self._count = 0
        self._sum = float(0)
        self._min = float('inf')
        self._max = float(0)
1200995
def reset(self):
        '''
        
        '''
        t = self
        while t._output is not None:
            t = t._output
        while t is not None:
            if t._pop and t._pop.returncode is None:
                t._pop.kill()
                t._pop.wait()
            del t._pop
            t._pop = None
            t = t._input
        return self
493767
function resetTracker() {
			var hoverSeries = chart.hoverSeries,
				hoverPoint = chart.hoverPoint;

			if (hoverPoint) {
				hoverPoint.onMouseOut();
			}

			if (hoverSeries) {
				hoverSeries.onMouseOut();
			}

			if (tooltip) {
				tooltip.hide();
			}

			hoverX = null;
		}
993869
def reset(self):
        
        self._variables_shim = {}
        self._executable = None
        self._bitstrings = None

        self.status = 'connected'
863359
def flush(self):
        """"""
        self._flush_nodes()
        self._flush_edges()
        self._flush_graph_val()
        self._flush_node_val()
        self._flush_edge_val()
434359
def reset(self):
        '''
        
        '''
        self.model = pm.Model()
        self.mu = None
        self.par_groups = {}
1105637
public void resetHard() {
      for( int i = 0; i < usedEdges.size(); i++ ) {
         Edge<N,E> e = usedEdges.get(i);
         e.data = null;
         e.dest = null;
      }

      for( int i = 0; i < usedNodes.size(); i++ ) {
         Node<N,E> n = usedNodes.get(i);
         n.data = null;
         n.edges.reset();
      }

      unusedEdges.addAll(usedEdges);
      unusedNodes.addAll(usedNodes);

      usedEdges.clear();
      usedNodes.clear();
   }