def find(sym):
from clojure.lang.namespace import find as findNamespace
if sym.ns is None:
raise InvalidArgumentException("Symbol must be namespace-qualified")
ns = findNamespace(symbol(sym.ns))
if ns is None:
raise InvalidArgumentException("No such namespace " + str(sym.ns))
return getattr(ns, sym.name)
def createWithCheck(self, init):
for i in range(0, len(init), 2):
for j in range(i + 2, len(init), 2):
if init[i] == init[j]:
raise InvalidArgumentException("Duplicate Key {0}".format(
init[i]))
return PersistentArrayMap(init)
def intern(ns, sym):
from clojure.lang.var import Var
if sym.ns is not None:
raise InvalidArgumentException("Can't intern namespace-qualified symbol")
ns = find(ns)
v = Var(ns, sym)
setattr(ns, sym.name, v)
return v
def __init__(self, *args):
if len(args) == 1:
if not isReader(args[0]):
raise InvalidArgumentException(
"must pass in a object with a read() method")
FileSeq.__init__(self, args[0], 1, 1, args[0].read(1))
return
elif len(args) == 4:
self.rdr, self.line, self.col, self.ccur = args
self._next = None
def conjToAssoc(self, o):
if isinstance(o, MapEntry):
return self.assoc(o.getKey(), o.getValue())
if hasattr(o, "__getitem__") and hasattr(o, "__len__"):
if len(o) != 2:
raise InvalidArgumentException("Vector arg must be a pair")
return self.assoc(o[0], o[1])
s = RT.seq(o)
map = self
for s in s.interator():
m = s.first()
map = map.assoc(m.getKey(), m.getValue())
return map
def cons(self, o):
if isinstance(o, MapEntry):
return self.assoc(o.getKey(), o.getValue())
if isinstance(o, IPersistentVector):
if len(o) != 2:
raise InvalidArgumentException("Vector arg to map conj must "
"be a pair")
return self.assoc(o[0], o[1])
ret = self
s = o.seq()
while s is not None:
e = s.first()
ret = ret.assoc(e.getKey(), e.getValue())
s = s.next()
return ret
def intern(ns, sym):
"""Interns a non-ns-qualified Symbol in a namespace.
"""
sym = Symbol(sym)
if sym.ns is not None:
raise InvalidArgumentException(
"Can't intern namespace-qualified symbol")
if not isinstance(ns, ModuleType):
raise InvalidArgumentException
v = getattr(ns, str(sym), None)
if v is not None:
if not isinstance(v, Var):
raise Exception("Can't redefine {0} as {1}: is not Var".format(
v, sym))
if ns.__name__ == v.ns.__name__:
return v
v = Var(ns, sym)
setattr(ns, sym.name, v)
return v
def set(*args):
from clojure.lang.persistenthashset import EMPTY
if len(args) == 0:
return EMPTY
if len(args) == 1:
if isinstance(args[0], dict):
m = EMPTY
for x in args[0]:
if x in m:
raise InvalidArgumentException("Duplicate key")
m.impl = m.impl.assoc(x, args[0][x])
return m
if fulfillsIndexable(args[0]):
args = args[0]
m = EMPTY
for x in range(0, len(args), 2):
key = args[x]
value = args[x + 1]
m.impl = m.impl.assoc(key, value)
return m
def keyword(*args):
if len(args) == 1:
if isinstance(args[0], Symbol):
sym = args[0]
if sym.meta() is not None:
sym = sym.withMeta(None)
k = Keyword(sym)
interned.mutate(lambda old: old
if sym in old else old.assoc(sym, k))
return interned.get()[sym]
elif isinstance(args[0], (str, unicode)):
return keyword(symbol(args[0]))
else:
raise InvalidArgumentException()
elif len(args) == 2:
return keyword(symbol(*args))
else:
raise ArityException()
def intern(ns, sym):
from clojure.lang.var import Var
if isinstance(sym, str):
sym = symbol(str)
if sym.ns is not None:
raise InvalidArgumentException(
"Can't intern namespace-qualified symbol")
ns = find(ns)
if hasattr(ns, str(sym)):
v = getattr(ns, str(sym))
if not isinstance(v, Var):
raise Exception("can't redefine " + str(v) + " as " + str(sym) +
": is not Var")
if ns.__name__ == v.ns.__name__:
return v
v = Var(ns, sym)
setattr(ns, sym.name, v)
return v
def back(self):
if self.old is None:
raise InvalidArgumentException("Can only go back once")
self.fs = self.old
self.old = None
