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
