def __init__(self, *args): """Var initializer Valid calls: - Var(namespace, symbol, root) - Var(namespace, symbol) -- unbound Var - Var(root) -- anonymous Var - Var() -- anonymous, unbound Var """ self.ns = args[0] if len(args) >= 2 else None self.sym = args[1] if len(args) >= 2 else None root = args[-1] if len(args) % 2 else UNKNOWN self.root = AtomicReference(root if root != UNKNOWN else Unbound(self)) self.threadBound = False self._meta = EMPTY self.dynamic = False self.public = True
def __init__(self, ns, sym, root=UKNOWN): self.ns = ns self.sym = sym self.threadBound = False if root == UKNOWN: self.root = AtomicReference(Unbound(self)) else: self.root = AtomicReference(root) self._meta = EMPTY self.rev = 0 self.dynamic = False self.public = True if isinstance(self.root.get(), Unbound): self.rev += 1
def __init__(self, ns, sym, root=UKNOWN): self.ns = ns self.sym = sym self.threadBound = False if root == UKNOWN: self.root = AtomicReference(Unbound(self)) else: self.root = AtomicReference(root) self._meta = EMPTY self.rev = 0 self.dynamic = False self.public = True if isinstance(self.root.get(), Unbound): self.rev += 1
def __init__(self, *args): """Var initializer Valid calls: - Var(namespace, symbol, root) - Var(namespace, symbol) -- unbound Var - Var(root) -- anonymous Var - Var() -- anonymous, unbound Var """ self.ns = args[0] if len(args) >= 2 else None self.sym = args[1] if len(args) >= 2 else None root = args[-1] if len(args) % 2 else UNKNOWN self.root = AtomicReference(root if root != UNKNOWN else Unbound(self)) self.threadBound = False self._meta = EMPTY self.dynamic = False self.public = True
class Keyword(IFn, Named, IPrintable): interned = AtomicReference(EMPTY_MAP) def __new__(cls, *args): """Keyword constructor. Argument(s) will be passed to Symbol() first. If the keyword was already interned, it will be returned. """ sym = Symbol(*args).withMeta(None) if sym in Keyword.interned.get(): return Keyword.interned.get()[sym] obj = super(Keyword, cls).__new__(cls) Keyword.interned.mutate( lambda old: old if sym in old else old.assoc(sym, obj)) obj.sym = sym obj.hash = hash(sym) + 0x9e3779b9 return obj def __hash__(self): return self.hash def __call__(self, obj, notFound=None): if obj is None: return None if self not in obj: return notFound return obj[self] def __repr__(self): return ":{0}".format(self.sym) def getNamespace(self): return self.sym.getNamespace() def getName(self): return self.sym.getName() def writeAsString(self, writer): writer.write(repr(self)) def writeAsReplString(self, writer): writer.write(repr(self))
def createNode(*args): if len(args) == 7: edit, shift, key1, val1, key2hash, key2, val2 = args elif len(args) == 6: shift, key1, val1, key2hash, key2, val2 = args edit = AtomicReference() else: raise ArityException() if shift > 64: raise Exception("Shift max reached") key1hash = hash(key1) if key1hash == key2hash: return HashCollisionNode(None, key1hash, 2, [key1, val1, key2, val2]) nbox = Box(None) nd1 = EMPTY_BITMAP_NODE \ .assocEd(edit, shift, key1hash, key1, val1, nbox) nd2 = nd1.assocEd(edit, shift, key2hash, key2, val2, nbox) return nd2
class Var(ARef, Settable, IFn, IPrintable): def __init__(self, *args): """Var initializer Valid calls: - Var(namespace, symbol, root) - Var(namespace, symbol) -- unbound Var - Var(root) -- anonymous Var - Var() -- anonymous, unbound Var """ self.ns = args[0] if len(args) >= 2 else None self.sym = args[1] if len(args) >= 2 else None root = args[-1] if len(args) % 2 else UNKNOWN self.root = AtomicReference(root if root != UNKNOWN else Unbound(self)) self.threadBound = False self._meta = EMPTY self.dynamic = False self.public = True def setDynamic(self, val=True): self.dynamic = val return self def isDynamic(self): return self.dynamic def setPublic(self, public=True): self.public = public def isPublic(self): return self.public def isBound(self): return self.getThreadBinding() is not None \ or not isinstance(self.root.get(), Unbound) def set(self, val): self.validate(self.getValidator(), val) b = self.getThreadBinding() if b is not None: if currentThread() != b.thread: raise IllegalStateException( "Can't set!: {0} from non-binding thread".format(self.sym)) b.val = val return self raise IllegalStateException( "Can't change/establish root binding of: {0} with set".format( self.sym)) def alterRoot(self, fn, args): return self.root.mutate(lambda old: fn(old, *(args if args else ()))) def hasRoot(self): return not isinstance(self.root.get(), Unbound) def bindRoot(self, root): self.validate(self.getValidator(), root) self.root.set(root) return self def __call__(self, *args, **kw): """Exists for Python interop, don't use in clojure code""" return self.deref()(*args, **kw) def deref(self): b = self.getThreadBinding() if b is not None: return b.val return self.root.get() def getThreadBinding(self): if self.threadBound: e = dvals.get(Frame).bindings.entryAt(self) if e is not None: return e.getValue() return None def setMeta(self, meta): self._meta = meta if self._meta and self._meta[STATIC_KEY]: self.setDynamic(False) return self def setMacro(self): self.alterMeta(lambda x, y, z: x.assoc(y, z), macrokey, True) def writeAsString(self, writer): writer.write(repr(self)) def writeAsReplString(self, writer): writer.write(repr(self)) def __repr__(self): if self.ns is not None: return "#'{0}/{1}".format(self.ns.__name__, self.sym) return "#<Var: {0}>".format(self.sym or "--unnamed--")
class Var(ARef, Settable, IFn, IPrintable): def __init__(self, ns, sym, root=UKNOWN): self.ns = ns self.sym = sym self.threadBound = False if root == UKNOWN: self.root = AtomicReference(Unbound(self)) else: self.root = AtomicReference(root) self._meta = EMPTY self.rev = 0 self.dynamic = False self.public = True if isinstance(self.root.get(), Unbound): self.rev += 1 def setDynamic(self, val=True): self.dynamic = val return self def isDynamic(self): return self.dynamic def setPublic(self, public = True): self.public = public def isPublic(self): return self.public def isBound(self): return self.getThreadBinding() is not None \ or not isinstance(self.root.get(), Unbound) def set(self, val): self.validate(self.getValidator(), val) b = self.getThreadBinding() if b is not None: if currentThread() != b.thread: raise IllegalStateException("Can't set!: " + str(self.sym) + " from non-binding thread") b.val = val return self raise IllegalStateException("Can't change/establish root binding " "of: %s with set" % str(self.sym)) def alterRoot(self, fn, args): return self.root.mutate(lambda old: fn(old, *(args if args else ()))) def hasRoot(self): return not isinstance(self.root.get(), Unbound) def bindRoot(self, root): self.validate(self.getValidator(), root) oldroot = self.root.get() self.root.set(root) self.rev += 1 return self def __call__(self, *args, **kw): """Exists for Python interop, don't use in clojure code""" return self.deref()(*args, **kw) def deref(self): b = self.getThreadBinding() if b is not None: return b.val return self.root.get() def getThreadBinding(self): if self.threadBound: e = dvals.get(lambda: Frame()).bindings.entryAt(self) if e is not None: return e.getValue() return None def setMeta(self, meta): self._meta = meta if self._meta and self._meta[STATIC_KEY]: self.setDynamic(False) return self def setMacro(self): self.alterMeta(lambda x, y, z: x.assoc(y, z), macrokey, True) def writeAsString(self, writer): writer.write(repr(self)) def writeAsReplString(self, writer): writer.write(repr(self)) def __repr__(self): if self.ns is not None: return "#'" + str(self.ns.__name__) + "/" + str(self.sym) return ("#<Var: " + (str(self.sym) if self.sym is not None else "--unnamed--") + ">")
s = RT.seq(seq) v = EMPTY while s is not None: v = v.cons(RT.first(s)) s = RT.next(s) return v def create(*args): """Return a PersistentVector. args -- zero or more objects The returned vector will contain all objects found in args.""" x = EMPTY for z in args: x = x.cons(z) return x # ====================================================================== # Pseudo-Singletons # ====================================================================== # currently unused (for Clojure's transient data structures) NOEDIT = AtomicReference() # A Node holding no children or vector values EMPTY_NODE = Node(NOEDIT) # A PersistentVector containing 0 items EMPTY = PersistentVector(0, 5, EMPTY_NODE, [])
class Var(ARef, Settable, IFn, IPrintable): def __init__(self, ns, sym, root=UKNOWN): self.ns = ns self.sym = sym self.threadBound = False if root == UKNOWN: self.root = AtomicReference(Unbound(self)) else: self.root = AtomicReference(root) self._meta = EMPTY self.rev = 0 self.dynamic = False self.public = True if isinstance(self.root.get(), Unbound): self.rev += 1 def setDynamic(self, val=True): self.dynamic = val return self def isDynamic(self): return self.dynamic def setPublic(self, public=True): self.public = public def isPublic(self): return self.public def isBound(self): return not isinstance(self.root.get(), Unbound) def set(self, val): self.validate(self.getValidator(), val) b = self.getThreadBinding() if b is not None: if currentThread() != b.thread: raise IllegalStateException("Can't set!: " + str(self.sym) + " from non-binding thread") b.val = val return self raise IllegalStateException("Can't change/establish root binding " "of: %s with set" % str(self.sym)) def alterRoot(self, fn, args): return self.root.mutate(lambda old: fn(old, *(args if args else ()))) def hasRoot(self): return not isinstance(self.root.get(), Unbound) def bindRoot(self, root): self.validate(self.getValidator(), root) oldroot = self.root.get() self.root.set(root) self.rev += 1 return self def __call__(self, *args, **kw): """Exists for Python interop, don't use in clojure code""" return self.deref()(*args, **kw) def deref(self): b = self.getThreadBinding() if b is not None: return b.val return self.root.get() def getThreadBinding(self): if self.threadBound: e = dvals.get(lambda: Frame()).bindings.entryAt(self) if e is not None: return e.getValue() return None def setMeta(self, meta): self._meta = meta if self._meta and self._meta[STATIC_KEY]: self.setDynamic(False) return self def setMacro(self): self.alterMeta(lambda x, y, z: x.assoc(y, z), macrokey, True) def writeAsString(self, writer): writer.write(repr(self)) def writeAsReplString(self, writer): writer.write(repr(self)) def __repr__(self): if self.ns is not None: return "#'" + str(self.ns.__name__) + "/" + str(self.sym) return ("#<Var: " + (str(self.sym) if self.sym is not None else "--unnamed--") + ">")
if self.s is not None: return createNodeSeq(self.array, self.i, self.s.next()) return createNodeSeq(self.array, self.i + 2, None) def createNodeSeq(*args): if len(args) == 1: if len(args[0]) == 0: return None return createNodeSeq(args[0], 0, None) if len(args) != 3: raise ArityException() array, i, s = args if s is not None: return NodeSeq(None, array, i, s) for j in range(i, len(array), 2): if array[j] is not None: return NodeSeq(None, array, j, None) node = array[j+1] if node is not None: nodeSeq = node.nodeSeq() if nodeSeq is not None: return NodeSeq(None, array, j + 2, nodeSeq) return None EMPTY = PersistentHashMap(0, None, False, None) EMPTY_BITMAP_NODE = BitmapIndexedNode(-1, 0, []) NOT_FOUND = AtomicReference()
from clojure.lang.symbol import Symbol, symbol from clojure.lang.persistenthashmap import EMPTY as EMPTY_MAP from clojure.lang.atomicreference import AtomicReference from clojure.lang.cljexceptions import InvalidArgumentException, ArityException from clojure.lang.iprintable import IPrintable import weakref from clojure.lang.ifn import IFn from clojure.lang.named import Named interned = AtomicReference(EMPTY_MAP) class Keyword(IFn, Named, IPrintable): def getNamespace(self): return self.sym.getNamespace() def getName(self): return self.sym.getName() def writeAsString(self, writer): writer.write(repr(self)) def writeAsReplString(self, writer): writer.write(repr(self)) def __init__(self, sym): self.sym = sym self.hash = hash(sym) + 0x9e3779b9 def __hash__(self): return self.hash
class Var(ARef, Settable, IFn, IPrintable): def __init__(self, *args): """Var initializer Valid calls: - Var(namespace, symbol, root) - Var(namespace, symbol) -- unbound Var - Var(root) -- anonymous Var - Var() -- anonymous, unbound Var """ self.ns = args[0] if len(args) >= 2 else None self.sym = args[1] if len(args) >= 2 else None root = args[-1] if len(args) % 2 else UNKNOWN self.root = AtomicReference(root if root != UNKNOWN else Unbound(self)) self.threadBound = False self._meta = EMPTY self.dynamic = False self.public = True def setDynamic(self, val=True): self.dynamic = val return self def isDynamic(self): return self.dynamic def setPublic(self, public = True): self.public = public def isPublic(self): return self.public def isBound(self): return self.getThreadBinding() is not None \ or not isinstance(self.root.get(), Unbound) def set(self, val): self.validate(self.getValidator(), val) b = self.getThreadBinding() if b is not None: if currentThread() != b.thread: raise IllegalStateException( "Can't set!: {0} from non-binding thread".format(self.sym)) b.val = val return self raise IllegalStateException( "Can't change/establish root binding of: {0} with set". format(self.sym)) def alterRoot(self, fn, args): return self.root.mutate(lambda old: fn(old, *(args if args else ()))) def hasRoot(self): return not isinstance(self.root.get(), Unbound) def bindRoot(self, root): self.validate(self.getValidator(), root) self.root.set(root) return self def __call__(self, *args, **kw): """Exists for Python interop, don't use in clojure code""" return self.deref()(*args, **kw) def deref(self): b = self.getThreadBinding() if b is not None: return b.val return self.root.get() def getThreadBinding(self): if self.threadBound: e = dvals.get(Frame).bindings.entryAt(self) if e is not None: return e.getValue() return None def setMeta(self, meta): self._meta = meta if self._meta and self._meta[STATIC_KEY]: self.setDynamic(False) return self def setMacro(self): self.alterMeta(lambda x, y, z: x.assoc(y, z), macrokey, True) def writeAsString(self, writer): writer.write(repr(self)) def writeAsReplString(self, writer): writer.write(repr(self)) def __repr__(self): if self.ns is not None: return "#'{0}/{1}".format(self.ns.__name__, self.sym) return "#<Var: {0}>".format(self.sym or "--unnamed--")
from clojure.lang.areference import AReference from clojure.lang.atomicreference import AtomicReference from clojure.lang.persistenthashmap import EMPTY as EMPTY_MAP from clojure.lang.cljexceptions import (InvalidArgumentException, IllegalStateException, ArityException, IllegalArgumentException) import clojure.lang.rt as RT from clojure.lang.symbol import Symbol, symbol import sys, types namespaces = AtomicReference(EMPTY_MAP) def areDifferentInstancesOfSameClassName(o1, o2): return o1.__class__ is o2.__class__ def addDefaultImports(mod): import clojure.lang.rt as RT import clojure.standardimports as stdimps for i in dir(stdimps): if i.startswith("_"): continue setattr(mod, i, getattr(stdimps, i)) if "clojure.core" in sys.modules: core = sys.modules["clojure.core"] for i in dir(core): if i.startswith("_"): continue setattr(mod, i, getattr(core, i)) return mod