used to recycle this
516011
public ClickableIconOverlay set(int id, IGeoPoint position, Drawable icon, DataType data) {
        set(position, icon);
        mId = id;
        mData = data;
        return this;
    }
948057
@Override
	public void recycle(MemorySegment segment) {
		int numAddedBuffers;

		synchronized (bufferQueue) {
			// Similar to notifyBufferAvailable(), make sure that we never add a buffer
			// after releaseAllResources() released all buffers (see below for details).
			if (isReleased.get()) {
				try {
					inputGate.returnExclusiveSegments(Collections.singletonList(segment));
					return;
				} catch (Throwable t) {
					ExceptionUtils.rethrow(t);
				}
			}
			numAddedBuffers = bufferQueue.addExclusiveBuffer(new NetworkBuffer(segment, this), numRequiredBuffers);
		}

		if (numAddedBuffers > 0 && unannouncedCredit.getAndAdd(numAddedBuffers) == 0) {
			notifyCreditAvailable();
		}
	}
367843
function processCleanupData(cleanupData, options) {
        var fns = [];

        cleanupData.forEach(function (item) {
            var reactData = item.reactData;
            var reactor = reactors[reactData.type + '.reactor'];
            var req = _.extend({ resourceName: item.resource.name, reactData: reactData }, options);

            fns.push(function () {
                log.info('Cleanup source=' + item.resource.name +
                    ' reactor=' + reactData.type +
                    ' target=' + (reactData.target || reactData.parent || reactData.child || ''));

                return reactor && reactor.cleanup ? reactor.cleanup(req) : new Q();
            });
        });

        return chainPromises(fns, {});
    }
681727
private void releaseEnvelope(Envelope envelope) {
		Buffer buffer = envelope.getBuffer();
		if (buffer != null) {
			buffer.recycleBuffer();
		}
	}
157829
void recycleSegment(final File file)
    {
        if (isCapExceeded()
            || CommitLogDescriptor.fromFileName(file.getName()).getMessagingVersion() != MessagingService.current_version)
        {
            // (don't decrease managed size, since this was never a "live" segment)
            logger.debug("(Unopened) segment {} is no longer needed and will be deleted now", file);
            FileUtils.deleteWithConfirm(file);
            return;
        }

        logger.debug("Recycling {}", file);
        // this wasn't previously a live segment, so add it to the managed size when we make it live
        size.addAndGet(DatabaseDescriptor.getCommitLogSegmentSize());
        segmentManagementTasks.add(new Callable<CommitLogSegment>()
        {
            public CommitLogSegment call()
            {
                return new CommitLogSegment(file.getPath());
            }
        });
    }
38924
def _recycle(self):
        
        origin = self._origin
        if origin == 0:
            return False
        available = self._extent - origin
        self._data[:available] = self._data[origin:self._extent]
        self._extent = available
        self._origin = 0
        #log_debug("Recycled %d bytes" % origin)
        return True
788195
public void cleanUp() {
	int nI;
	for (nI = 0; nI < PBOX_ENTRIES; nI++)
	    m_pbox[nI] = 0;
	for (nI = 0; nI < SBOX_ENTRIES; nI++)
	    m_sbox1[nI] = m_sbox2[nI] = m_sbox3[nI] = m_sbox4[nI] = 0;
    }
1043444
CommitLogSegment recycle()
    {
        try
        {
            sync();
        }
        catch (FSWriteError e)
        {
            logger.error("I/O error flushing {} {}", this, e.getMessage());
            throw e;
        }

        close();

        return new CommitLogSegment(getPath());
    }
372498
@Override
   void recycle(final PoolEntry poolEntry)
   {
      metricsTracker.recordConnectionUsage(poolEntry);

      connectionBag.requite(poolEntry);
   }
596693
protected void recycleData() {
		for (int i = 0; i < nodes.size(); i++) {
			SquareNode n = nodes.get(i);
			for (int j = 0; j < n.edges.length; j++) {
				if( n.edges[j] != null ) {
					graph.detachEdge(n.edges[j]);
				}
			}
		}
		for (int i = 0; i < nodes.size(); i++) {
			SquareNode n = nodes.get(i);
			for (int j = 0; j < n.edges.length; j++) {
				if( n.edges[j] != null )
					throw new RuntimeException("BUG!");
			}
		}

		nodes.reset();

		for (int i = 0; i < clusters.size; i++) {
			clusters.get(i).clear();
		}
		clusters.reset();
	}
108212
public void recycle() {
        try {
            recycleSoundMap();
            if (soundPool != null) {
                soundPool.release();
                soundPool = null;
            }

        } catch (Exception ex) {
            Log.e(TAG, "", ex);
        }
    }
541473
def on_recycle_view(self, index, position):
        
        item = self.list_items[index]
        self.item_mapping[position] = item
        item.recycle_view(position)
1350968
public static void recycle(@NotNull ByteBuf buf) {
		int slab = 32 - numberOfLeadingZeros(buf.array.length - 1);
		ByteBufConcurrentStack stack = slabs[slab];
		stack.push(buf);
	}
728088
public <T> void recycle(ElementDescriptor<T> descriptor, T object)
	{
		if (object != null)
		{
			mRecycledObjects.put(descriptor, object);
		}
	}
1232516
Entry[] reuseChunkArray() {
    Entry[] ea = evictChunkReuse;
    if (ea != null) {
      evictChunkReuse = null;
    } else {
      ea = new Entry[chunkSize];
    }
    return ea;
  }
720227
def _clean_item(self, item):
        '''
        
        '''
        item_copy = dict(item)
        del item_copy['body']
        del item_copy['links']
        del item_copy['response_headers']
        del item_copy['request_headers']
        del item_copy['status_code']
        del item_copy['status_msg']
        item_copy['action'] = 'ack'
        item_copy['logger'] = self.logger.name
        item_copy

        return item_copy
938870
protected void recycleAllFrom(@Nullable ViewGroup layout) {
        if (!useRecycler || layout == null) {
            return;
        }

        for (int i = 0, size = layout.getChildCount(); i < size; i++) {
            final View view = layout.getChildAt(i);
            final int viewType = (Integer) view.getTag(TAG_TYPE_ID);
            final Queue<View> cache = getViewsCache(viewType);
            if (cache != null) {
                cache.offer(view);
                onRecycleView(view);
            }
        }

        layout.removeAllViews();
    }