Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/***** BEGIN LICENSE BLOCK *****
* Version: CPL 1.0/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Common Public
* License Version 1.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.eclipse.org/legal/cpl-v10.html
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* Copyright (C) 2002-2004 Jan Arne Petersen
* Copyright (C) 2002-2004 Anders Bengtsson
* Copyright (C) 2004-2006 Charles O Nutter
* Copyright (C) 2004 Stefan Matthias Aust
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the CPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the CPL, the GPL or the LGPL.
***** END LICENSE BLOCK *****/
package org.jruby.runtime;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
import org.jruby.RubyModule;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.util.WeakIdentityHashMap;
/**
* FIXME: This version is faster than the previous, but both suffer from a
* crucial flaw: It is impossible to create an ObjectSpace with an iterator
* that doesn't either: a. hold on to objects that might otherwise be collected
* or b. have no way to guarantee that a call to hasNext() will be correct or
* that a subsequent call to next() will produce an object. For our purposes,
* for now, this may be acceptable.
*/
public class ObjectSpace {
private ReferenceQueue deadReferences = new ReferenceQueue();
private WeakReferenceListNode top;
private ReferenceQueue deadIdentityReferences = new ReferenceQueue();
private final Map identities = new HashMap();
private final Map identitiesByObject = new WeakIdentityHashMap();
private static final AtomicLong maxId = new AtomicLong(1000);
public void registerObjectId(long id, IRubyObject object) {
synchronized (identities) {
cleanIdentities();
identities.put(id, new IdReference(object, id, deadIdentityReferences));
identitiesByObject.put(object, id);
}
}
public static long calculateObjectId(Object object) {
// Fixnums get all the odd IDs, so we use identityHashCode * 2
return maxId.getAndIncrement() * 2;
}
public long createAndRegisterObjectId(IRubyObject rubyObject) {
synchronized (identities) {
Long longId = (Long) identitiesByObject.get(rubyObject);
if (longId == null) {
longId = createId(rubyObject);
}
return longId.longValue();
}
}
private long createId(IRubyObject object) {
long id = calculateObjectId(object);
registerObjectId(id, object);
return id;
}
public IRubyObject id2ref(long id) {
synchronized (identities) {
cleanIdentities();
IdReference reference = (IdReference) identities.get(Long.valueOf(id));
if (reference == null) {
return null;
}
return (IRubyObject) reference.get();
}
}
private void cleanIdentities() {
IdReference ref;
while ((ref = (IdReference) deadIdentityReferences.poll()) != null)
identities.remove(Long.valueOf(ref.id()));
}
@Deprecated
public long idOf(IRubyObject rubyObject) {
return createAndRegisterObjectId(rubyObject);
}
public void addFinalizer(IRubyObject object, IRubyObject proc) {
object.addFinalizer(proc);
}
public void removeFinalizers(long id) {
IRubyObject object = id2ref(id);
if (object != null) {
object.removeFinalizers();
}
}
public synchronized void add(IRubyObject object) {
cleanup();
top = new WeakReferenceListNode(object, deadReferences, top);
}
public synchronized Iterator iterator(RubyModule rubyClass) {
final List objList = new ArrayList();
WeakReferenceListNode current = top;
while (current != null) {
IRubyObject obj = (IRubyObject)current.get();
if (obj != null && rubyClass.isInstance(obj)) {
objList.add(current);
}
current = current.nextNode;
}
return new Iterator() {
private Iterator iter = objList.iterator();
public boolean hasNext() {
throw new UnsupportedOperationException();
}
public Object next() {
Object obj = null;
while (iter.hasNext()) {
WeakReferenceListNode node = (WeakReferenceListNode)iter.next();
obj = node.get();
if (obj != null) break;
}
return obj;
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
private synchronized void cleanup() {
WeakReferenceListNode reference;
while ((reference = (WeakReferenceListNode)deadReferences.poll()) != null) {
reference.remove();
}
}
private class WeakReferenceListNode extends WeakReference {
private WeakReferenceListNode prevNode;
private WeakReferenceListNode nextNode;
public WeakReferenceListNode(Object ref, ReferenceQueue queue, WeakReferenceListNode next) {
super(ref, queue);
this.nextNode = next;
if (next != null) {
next.prevNode = this;
}
}
public void remove() {
synchronized (ObjectSpace.this) {
if (prevNode != null) {
prevNode.nextNode = nextNode;
} else {
top = nextNode;
}
if (nextNode != null) {
nextNode.prevNode = prevNode;
}
}
}
}
private static class IdReference extends WeakReference {
private final long id;
public IdReference(IRubyObject object, long id, ReferenceQueue queue) {
super(object, queue);
this.id = id;
}
public long id() {
return id;
}
}
}
