Used to reset a reset a reader group to a checkpoint. This should be removed in time.
@deprecated Use {@link ReaderGroup#resetReaderGroup(ReaderGroupConfig)} to reset readers to a given Checkpoint.
353811
@Override
    @Deprecated
    public void resetReadersToCheckpoint(Checkpoint checkpoint) {
        synchronizer.updateState((state, updates) -> {
            ReaderGroupConfig config = state.getConfig();
            Map<Segment, Long> positions = new HashMap<>();
            for (StreamCut cut : checkpoint.asImpl().getPositions().values()) {
                positions.putAll(cut.asImpl().getPositions());
            }
            updates.add(new ReaderGroupStateInit(config, positions, getEndSegmentsForStreams(config)));
        });
    }
689851
public void reset( Reader input ) throws IOException
    { 
        if ( input != null ) {
            reader = new IPushbackReader(new BufferedReader(input));
        }
        
        idx = -1;
    }
302198
private void unmap() {
    if (storageLevel == StorageLevel.MAPPED) {
      writer.unmap();
      readers.forEach(reader -> reader.unmap());
    }
  }
1306101
private void deleteGroup(List<Segment> group) {
    // Delete the old segments.
    for (Segment oldSegment : group) {
      oldSegment.close();
      oldSegment.delete();
    }
  }
1233959
public void takeClassificationReadLock()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "takeClassificationReadLock");
    
    classificationReadLock.lock();
    
    if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "takeClassificationReadLock");
  }
382683
def reset_group_subscription(self):
        """"""
        if self._user_assignment:
            raise IllegalStateError(self._SUBSCRIPTION_EXCEPTION_MESSAGE)
        assert self.subscription is not None, 'Subscription required'
        self._group_subscription.intersection_update(self.subscription)
285491
@Override
    public void read(final Reader reader) throws ConfigurationException, IOException {
        Preconditions.checkNotNull(reader);

        final HashMap<String, Object> settings = this.mapper.readValue(reader, HASH_MAP_TYPE_REFERENCE);
        final ImmutableNode rootNode = toNode(new Builder(), settings);
        this.getSubConfigurationParentModel().mergeRoot(rootNode, null, null, null, this);
    }
888151
@Override
    public void deleteGroup(IEntityGroup group) throws GroupsException {
        throwExceptionIfNotInternallyManaged();
        synchronizeGroupMembersOnDelete(group);
        getGroupStore().delete(group);
        if (cacheInUse()) {
            cacheRemove(group);
        }
    }
561156
def removereadergroup(self, group):
        """"""

        hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
        if 0 != hresult:
            raise error(
                'Failed to establish context: ' + \
                SCardGetErrorMessage(hresult))
        try:
            hresult = SCardForgetReaderGroup(hcontext, group)
            if hresult != 0:
                raise error(
                    'Unable to forget reader group: ' + \
                    SCardGetErrorMessage(hresult))
            else:
                innerreadergroups.removereadergroup(self, group)

        finally:
            hresult = SCardReleaseContext(hcontext)
            if 0 != hresult:
                raise error(
                    'Failed to release context: ' + \
                    SCardGetErrorMessage(hresult))
415384
public boolean removeReader(Object key, Object resourceId)
    {
        boolean result = false;
        ObjectLocks objectLocks = null;
        synchronized(locktable)
        {
            objectLocks = (ObjectLocks) locktable.get(resourceId);
            if(objectLocks != null)
            {
                /**
                 * MBAIRD, last one out, close the door and turn off the lights.
                 * if no locks (readers or writers) exist for this object, let's remove
                 * it from the locktable.
                 */
                Map readers = objectLocks.getReaders();
                result = readers.remove(key) != null;
                if((objectLocks.getWriter() == null) && (readers.size() == 0))
                {
                    locktable.remove(resourceId);
                }
            }
        }
        return result;
    }
1060630
@Override
    public synchronized void registerReader(ReadMarker readMarker, MessageReader... reader) {
        Preconditions.checkArgument(reader!=null && reader.length>0,"Must specify at least one reader");
        registerReaders(readMarker,Arrays.asList(reader));
    }
40577
def addReadGroup(self, readGroup):
        
        id_ = readGroup.getId()
        self._readGroupIdMap[id_] = readGroup
        self._readGroupIds.append(id_)
624825
def OnRemoveReaders(self, removedreaders):
        """"""
        self.mutex.acquire()
        try:
            parentnode = self.root
            for readertoremove in removedreaders:
                (childReader, cookie) = self.GetFirstChild(parentnode)
                while childReader.IsOk():
                    if self.GetItemText(childReader) == str(readertoremove):
                        self.Delete(childReader)
                    else:
                        (childReader, cookie) = \
                            self.GetNextChild(parentnode, cookie)
            self.Expand(self.root)
        finally:
            self.mutex.release()
        self.EnsureVisible(self.root)
        self.Repaint()
340988
protected function resetOriginalReadPreference(){

        /** @var ReadPreference $dbReadPref */
        $dbReadPref = $this->db->__debugInfo()['readPreference'];
        if($this->originalDbReadPreference !== $dbReadPref->getMode())
        {
            $pref = (isset($this->originalDbReadPreference)
                ? $this->originalDbReadPreference
                : $this->readPreference
            );
            $dbTagsets = $dbReadPref->getTagsets();

            $this->db = $this->db->withOptions(array(
                'readPreference' => new ReadPreference($pref, $dbTagsets)
            ));
        }

        // Reset collection object
        /** @var ReadPreference $collReadPref */
        $collReadPref = $this->getCollection()->__debugInfo()['readPreference'];
        if($this->originalCollectionReadPreference !== $collReadPref->getMode()){
            $pref = (isset($this->originalCollectionReadPreference)
                ? $this->originalCollectionReadPreference
                : $this->readPreference
            );
            $collTagsets = $collReadPref->getTagsets();
            $this->collection = $this->collection->withOptions(array(
                'readPreference' => new ReadPreference($pref, $collTagsets)
            ));
        }
    }
266173
public GroupsConfigurationBuilder clearGroupers() {
      List<Grouper<?>> groupers = attributes.attribute(GROUPERS).get();
      groupers.clear();
      attributes.attribute(GROUPERS).set(groupers);
      return this;
   }
393940
private void markUngroupedEnclosedNodes(InstructionGroup group) {
        while_:
        while (true) {
            for (int i = getIndexOfFirstInsn(group), max = getIndexOfLastInsn(group); i < max; i++) {
                InstructionGraphNode node = method.getGraphNodes().get(i);
                if (node.getGroup() == null) {
                    markGroup(node, group);
                    sort(group);
                    continue while_;
                }
            }
            break;
        }
    }
743968
@Override
  public synchronized void reset() {
    finish = false;
    finished = false;
    uncompressedDirectBuf.clear();
    uncompressedDirectBufLen = 0;
    compressedDirectBuf.clear();
    compressedDirectBuf.limit(0);
    userBufOff = userBufLen = 0;
    bytesRead = bytesWritten = 0L;
  }