Uses of Class
convex.core.data.ACell

Packages that use ACell

Package	Description
convex.core	Fundamental Convex classes used for the decentralised network
convex.core.crypto	Crypto algorithms used within Convex, particularly for digital signatures and cryptographic hashes
convex.core.crypto.bc
convex.core.crypto.wallet
convex.core.data	Data structures and algorithms, including a complete set of classes required to implement immutable, decentralised data objects.
convex.core.data.impl
convex.core.data.prim	Implementation of CVM Primitive Data types
convex.core.data.type	CVM type system implementation.
convex.core.data.util
convex.core.exceptions	Specialised exception classes used in the Convex implementation and libraries
convex.core.lang	Core CVM implementation
convex.core.lang.impl	Internal CVM language implementation classes
convex.core.lang.ops	CVM Operations, effectively the "machine code" of the CVM
convex.core.lang.reader	Implementation of the standard Convex Lisp Reader
convex.core.store	Etch database for convergent immutable storage
convex.core.transactions	Convex network transaction types.
convex.core.util	Convex utility classes and miscellaneous functionality
convex.dlfs
convex.dlfs.impl
etch	Convex network transaction types.

Uses of ACell in convex.core

Subclasses of ACell in convex.core

Modifier and Type	Class	Description
class	Belief	Class representing a Peer's view of the overall network consensus state.
final class	Block	A Block contains an ordered collection of signed transactions that may be applied collectively as part of a state update.
class	BlockResult	Class representing the result of applying a Block to a State.
class	Order	Class representing an Ordering of transactions, along with the consensus position.
class	Receipt	Transaction Receipt record.
final class	Result	Class representing the result of a Query or Transaction.
class	State	Class representing the immutable state of the CVM State transitions are represented by blocks of transactions, according to the logic: s[n+1] = s[n].applyBlock(b[n]) State contains the following elements - Map of AccountStatus for every Address - Map of PeerStatus for every Peer Address - Global values - Schedule data structure "State.

Fields in convex.core with type parameters of type ACell

Modifier and Type	Field	Description
static final Index<ABlob,AVector<ACell>>	State.EMPTY_SCHEDULE
static final AVector<ACell>	Constants.INITIAL_GLOBALS	Initial global values for a new State

Methods in convex.core with type parameters of type ACell

Modifier and Type	Method	Description
<R extends ACell> Ref<R>	Belief.getRef(int i)
<R extends ACell> Ref<R>	Block.getRef(int i)
<R extends ACell> Ref<R>	BlockResult.getRef(int i)
<R extends ACell> Ref<R>	Order.getRef(int i)
<R extends ACell> Ref<R>	Receipt.getRef(int i)
<R extends ACell> Ref<R>	State.getRef(int i)
<T extends ACell> T	Result.getValue()	Returns the value for this result.
<T extends ACell> SignedData<T>	BeliefMerge.sign(T value)	Sign a value using the keypair for this MergeContext
<T extends ACell> SignedData<T>	Peer.sign(T value)	Signs a value with the keypair of this Peer

Methods in convex.core that return ACell

Modifier and Type	Method	Description
ACell	Belief.get(Keyword k)
ACell	Block.get(Keyword k)
ACell	BlockResult.get(Keyword key)
ACell	Order.get(Keyword key)
ACell	Receipt.get(Keyword k)
ACell	State.get(Keyword k)
ACell	BlockResult.getErrorCode(long i)	Gets the error code for a given transaction
ACell	Receipt.getErrorCode()	Gets the error code of this Receipt, or null if not an error
ACell	Result.getErrorCode()	Returns the Error Code from this Result.
ACell	ResultContext.getErrorCode()
ACell	Result.getID()	Returns the message ID for this result.
ACell	Receipt.getResult()	Gets the result value of this Receipt, or null if an error
ACell	ResultContext.getResult()

Methods in convex.core that return types with arguments of type ACell

Modifier and Type	Method	Description
AMap<Symbol,ACell>	State.getEnvironment(Address addr)	Gets the environment for a given account, or null if not found.
AVector<ACell>	State.getGlobals()	Gets globals.
AMap<Keyword,ACell>	Result.getInfo()	Returns the info for this Result.
AVector<AVector<ACell>>	Result.getLog()	Returns the log for this Result.
static AMap<Keyword,ACell>	Peer.getPeerData(AStore store)	Like Peer.getPeerData(AStore, ACell) but uses a null root key.
static AMap<Keyword,ACell>	Peer.getPeerData(AStore store, ACell rootKey)	Gets Peer Data from a Store.
Index<ABlob,AVector<ACell>>	State.getSchedule()	Gets the current schedule data structure for this state
AMap<Keyword,ACell>	Peer.toData()	Gets the Peer Data map for this Peer
AVector<ACell>	Result.values()

Methods in convex.core with parameters of type ACell

Modifier and Type	Method	Description
static Receipt	Receipt.create(boolean isError, ACell value, AVector<AVector<ACell>> log)
static Receipt	Receipt.create(ACell result)
static Result	Result.create(CVMLong id, ACell value)	Create a Result
static Result	Result.create(CVMLong id, ACell value, ACell errorCode)	Create a Result
static Result	Result.create(CVMLong id, ACell value, ACell errorCode, AHashMap<Keyword,ACell> info)	Create a Result
static Receipt	Receipt.createError(ACell errorCode)
boolean	Belief.equals(ACell a)
boolean	Block.equals(ACell a)
boolean	BlockResult.equals(ACell a)
boolean	Order.equals(ACell o)
boolean	Receipt.equals(ACell a)
boolean	State.equals(ACell a)
ResultContext	Peer.executeQuery(ACell form)	Executes a query in this Peer's current Consensus State, using a default address
ResultContext	Peer.executeQuery(ACell form, Address address)	Compiles and executes a query on the current consensus state of this Peer.
static Collection<SignedData<Order>>	Belief.extractOrders(ACell payload)	Extract a collection of Orders from a Cell, suitable for Belief merge
static AMap<Keyword,ACell>	Peer.getPeerData(AStore store, ACell rootKey)	Gets Peer Data from a Store.
static Peer	Peer.restorePeer(AStore store, AKeyPair keyPair, ACell rootKey)	Restores a Peer from the Etch database specified in Config
Result	Result.withID(ACell id)	Updates result with a given message ID.

Method parameters in convex.core with type arguments of type ACell

Modifier and Type	Method	Description
static Result	Result.buildFromVector(AVector<ACell> values)
static Receipt	Receipt.create(boolean isError, ACell value, AVector<AVector<ACell>> log)
static Result	Result.create(CVMLong id, ACell value, ACell errorCode, AHashMap<Keyword,ACell> info)	Create a Result
static Peer	Peer.fromData(AKeyPair keyPair, AMap<Keyword,ACell> peerData)	Constructs a Peer instance from persisted PEer Data
Result	Result.withExtraInfo(Map<Keyword,ACell> extInfo)
protected Result	Result.withValues(AVector<ACell> newValues)

Constructors in convex.core with parameters of type ACell

Modifier	Constructor	Description
protected	Receipt(boolean error, ACell value, AVector<AVector<ACell>> log)

Constructor parameters in convex.core with type arguments of type ACell

Modifier	Constructor	Description
protected	Receipt(boolean error, ACell value, AVector<AVector<ACell>> log)

Uses of ACell in convex.core.crypto

Subclasses of ACell in convex.core.crypto

Modifier and Type	Class	Description
class	ASignature	Class representing a cryptographic signature
class	Ed25519Signature	Immutable data value class representing an Ed25519 digital signature.

Methods in convex.core.crypto with type parameters of type ACell

Modifier and Type	Method	Description
abstract <R extends ACell> SignedData<R>	AKeyPair.signData(R value)	Signs a data value with this key pair

Uses of ACell in convex.core.crypto.bc

Methods in convex.core.crypto.bc with type parameters of type ACell

Modifier and Type	Method	Description
<R extends ACell> SignedData<R>	BCKeyPair.signData(R value)

Uses of ACell in convex.core.crypto.wallet

Methods in convex.core.crypto.wallet with type parameters of type ACell

Modifier and Type	Method	Description
<R extends ACell> SignedData<R>	HotWalletEntry.sign(R message)

Uses of ACell in convex.core.data

Classes in convex.core.data with type parameters of type ACell

Modifier and Type	Class	Description
class	ABlobLike<T extends ACell>	Abstract base class for Blob-like objects, which conceptually behave as a sequence of bytes.
class	ACollection<T extends ACell>	Abstract base class for Persistent Merkle Collections
class	ACountable<E extends ACell>	Abstract base class for Countable objects, supporting `count`, `nth`, `empty?` and `slice` Countable values support a count of elements and the ability to get by an element index.
class	ADataStructure<E extends ACell>	Abstract base class for Persistent data structures.
class	AHashMap<K extends ACell,V extends ACell>
class	AHashMap<K extends ACell,V extends ACell>
class	AHashSet<T extends ACell>
class	AIndex<K extends ABlobLike<?>,V extends ACell>	Abstract base class for Indexes: a sorted radix-tree map of Blobs to Values.
class	AList<T extends ACell>	Abstract base class for lists.
class	AMap<K extends ACell,V extends ACell>	Abstract base class for maps.
class	AMap<K extends ACell,V extends ACell>	Abstract base class for maps.
class	AMapEntry<K extends ACell,V extends ACell>
class	AMapEntry<K extends ACell,V extends ACell>
class	ASequence<T extends ACell>	Abstract base class for concrete sequential data structure (immutable persistent lists and vectors etc.)
class	ASet<T extends ACell>	Abstract based class for sets.
class	ASpecialVector<T extends ACell>	BAse class for specialised vector implementations
class	AVector<T extends ACell>	Abstract base class for vectors.
interface	IAssociative<K extends ACell,V extends ACell>	Interface for associative data structures
interface	IAssociative<K extends ACell,V extends ACell>	Interface for associative data structures
final class	Index<K extends ABlobLike<?>,V extends ACell>	Index node implementation, providing an efficient radix tree based immutable data structure for indexed access and sorting.
class	List<T extends ACell>	Implementation of a list wrapping a vector.
class	MapEntry<K extends ACell,V extends ACell>	Map.Entry implementation for persistent maps.
class	MapEntry<K extends ACell,V extends ACell>	Map.Entry implementation for persistent maps.
class	MapLeaf<K extends ACell,V extends ACell>	Limited size Persistent Merkle Map implemented as a small sorted list of Key/Value pairs Must be sorted by Key hash value to ensure uniqueness of representation
class	MapLeaf<K extends ACell,V extends ACell>	Limited size Persistent Merkle Map implemented as a small sorted list of Key/Value pairs Must be sorted by Key hash value to ensure uniqueness of representation
class	MapTree<K extends ACell,V extends ACell>	Persistent Map for large hash maps requiring tree structure.
class	MapTree<K extends ACell,V extends ACell>	Persistent Map for large hash maps requiring tree structure.
class	Ref<T extends ACell>	Class representing a smart reference to a decentralised data value.
class	RefDirect<T extends ACell>	Ref subclass for direct in-memory references.
class	RefSoft<T extends ACell>	Reference class implemented via a soft reference and store lookup.
class	SetLeaf<T extends ACell>	Limited size Persistent Merkle Set implemented as a small sorted list of Values Must be sorted by Key hash value to ensure uniqueness of representation
class	SetTree<T extends ACell>	Persistent Set for large hash sets requiring tree structure.
final class	SignedData<T extends ACell>	Node representing a signed data object.
class	VectorArray<T extends ACell>	Non-canonical vector implementation designed to make operations on small temporary vectors more efficient.
class	VectorLeaf<T extends ACell>	A Persistent Vector implementation representing 0-16 elements with a packed Vector prefix.
class	VectorTree<T extends ACell>	Persistent Vector implemented as a merkle tree of chunks shift indicates the level of the tree: 4 = 1st level, 8 = second etc.

Subclasses of ACell in convex.core.data

Modifier and Type	Class	Description
class	AArrayBlob	Abstract base class for binary data stored in Java arrays.
class	ABlob	Abstract base class for data objects containing immutable chunks of binary data.
class	ABlobLike<T extends ACell>	Abstract base class for Blob-like objects, which conceptually behave as a sequence of bytes.
class	AccountKey	Immutable class representing an Ed25519 Public Key for an Account
class	AccountStatus	Class representing the current on-chain status of an account.
class	ACollection<T extends ACell>	Abstract base class for Persistent Merkle Collections
class	ACountable<E extends ACell>	Abstract base class for Countable objects, supporting `count`, `nth`, `empty?` and `slice` Countable values support a count of elements and the ability to get by an element index.
class	ADataStructure<E extends ACell>	Abstract base class for Persistent data structures.
final class	Address	Immutable class representing an Address, generally used to uniquely identify an Account.
class	ADerivedBlob	Abstract Blob base base for Blobs that derive their functionality from other sources.
class	AHashMap<K extends ACell,V extends ACell>
class	AHashSet<T extends ACell>
class	AIndex<K extends ABlobLike<?>,V extends ACell>	Abstract base class for Indexes: a sorted radix-tree map of Blobs to Values.
class	AList<T extends ACell>	Abstract base class for lists.
class	ALongBlob
class	AMap<K extends ACell,V extends ACell>	Abstract base class for maps.
class	AMapEntry<K extends ACell,V extends ACell>
class	ARecord	Base class for Record data types.
class	ARecordGeneric	Abstract base class for generic records.
class	ASequence<T extends ACell>	Abstract base class for concrete sequential data structure (immutable persistent lists and vectors etc.)
class	ASet<T extends ACell>	Abstract based class for sets.
class	ASpecialVector<T extends ACell>	BAse class for specialised vector implementations
class	AString	Abstract base Class representing a CVM String.
class	ASymbolic	Abstract based class for symbolic objects (Keywords, Symbols)
class	AVector<T extends ACell>	Abstract base class for vectors.
class	Blob	General purpose immutable wrapper for byte array data.
class	BlobTree	Implementation of a large Blob data structure consisting of 2 or more chunks.
class	Hash	Class used to represent an immutable 32-byte Hash value.
final class	Index<K extends ABlobLike<?>,V extends ACell>	Index node implementation, providing an efficient radix tree based immutable data structure for indexed access and sorting.
final class	Keyword	Keyword data type.
class	List<T extends ACell>	Implementation of a list wrapping a vector.
final class	LongBlob	Wrapper for an 8-byte long as a Blob We use this mainly for efficient management of indexes using Longs in Indexes.
class	MapEntry<K extends ACell,V extends ACell>	Map.Entry implementation for persistent maps.
class	MapLeaf<K extends ACell,V extends ACell>	Limited size Persistent Merkle Map implemented as a small sorted list of Key/Value pairs Must be sorted by Key hash value to ensure uniqueness of representation
class	MapTree<K extends ACell,V extends ACell>	Persistent Map for large hash maps requiring tree structure.
class	PeerStatus	Class describing the on-chain state of a Peer declared on the network.
class	SetLeaf<T extends ACell>	Limited size Persistent Merkle Set implemented as a small sorted list of Values Must be sorted by Key hash value to ensure uniqueness of representation
class	SetTree<T extends ACell>	Persistent Set for large hash sets requiring tree structure.
final class	SignedData<T extends ACell>	Node representing a signed data object.
final class	StringShort	Class representing a short CVM string, backed by a flat Blob Used for most small strings, and acts as the leaf chunk for StringTrees
class	StringSlice	AString subclass representing a view some String data.
class	StringTree	String implementation class wrapping a BlobTree.
final class	Symbol	Class representing a Symbol.
final class	Syntax	Class representing a Syntax Object.
class	VectorArray<T extends ACell>	Non-canonical vector implementation designed to make operations on small temporary vectors more efficient.
class	VectorLeaf<T extends ACell>	A Persistent Vector implementation representing 0-16 elements with a packed Vector prefix.
class	VectorTree<T extends ACell>	Persistent Vector implemented as a merkle tree of chunks shift indicates the level of the tree: 4 = 1st level, 8 = second etc.

Fields in convex.core.data declared as ACell

Modifier and Type	Field	Description
static final ACell[]	Cells.EMPTY_ARRAY	An empty Java array of cells

Fields in convex.core.data with type parameters of type ACell

Modifier and Type	Field	Description
protected Ref<ACell>	ACell.cachedRef	Cached Ref.
protected AVector<ACell>	ARecordGeneric.values

Methods in convex.core.data with type parameters of type ACell

Modifier and Type	Method	Description
static <T extends ACell> T	Cells.announce(T a, Consumer<Ref<ACell>> noveltyHandler)	Announces a Cell, reporting as novelty any cells that have not been previously announced
static <K extends ACell, V extends ACell, R extends AMap<K, V>> R	Maps.coerce(AMap<?,?> m)
static <K extends ACell, V extends ACell, R extends AMap<K, V>> R	Maps.coerce(AMap<?,?> m)
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.create(MapEntry<K,V> me)
static <R extends AIndex<K, V>, K extends ABlobLike<?>, V extends ACell> R	Index.create(HashMap<K,V> map)
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.create(K k, V v)
static <T extends ACell> List<T>	List.create(ACell... args)	Creates a list wrapping the given array.
static <T extends ACell, L extends AList<T>> L	Lists.create(List<T> list)
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.create(K key, V value)	Creates a new MapEntry with the provided key and value
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.create(K key, V value)	Creates a new MapEntry with the provided key and value
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.create(MapEntry<K,V> item)
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.create(MapEntry<K,V> item)
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.create(MapEntry<K,V>[] entries)	Creates a ListMap with the specified entries.
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.create(MapEntry<K,V>[] entries)	Creates a ListMap with the specified entries.
protected static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.create(MapEntry<K,V>[] entries, int offset, int length)	Creates a MapLeaf with the specified entries.
protected static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.create(MapEntry<K,V>[] entries, int offset, int length)	Creates a MapLeaf with the specified entries.
static <R extends AHashMap<K, V>, K extends ACell, V extends ACell> R	Maps.create(ACell[] keysAndValues)	Constructs a map with the given keys and values.
static <R extends AHashMap<K, V>, K extends ACell, V extends ACell> R	Maps.create(ACell[] keysAndValues)	Constructs a map with the given keys and values.
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.create(List<MapEntry<K,V>> entries)	Create a map with a collection of entries.
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.create(List<MapEntry<K,V>> entries)	Create a map with a collection of entries.
static <K extends ACell, V extends ACell> MapLeaf<K,V>	Maps.create(K k, V v)
static <K extends ACell, V extends ACell> MapLeaf<K,V>	Maps.create(K k, V v)
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.create(MapEntry<K,V>[] newEntries, int shift)
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.create(MapEntry<K,V>[] newEntries, int shift)
static <T extends ACell> RefDirect<T>	RefDirect.create(T value)	Creates a new Direct ref to the given value.
static <T extends ACell> RefSoft<T>	RefSoft.create(AStore store, T value, int flags)
static <V extends ACell> SetLeaf<V>	SetLeaf.create(Ref<V>... elements)	Creates a SetLeaf with the specified elements.
protected static <V extends ACell> SetLeaf<V>	SetLeaf.create(Ref<V>[] entries, int offset, int length)	Creates a SetLeaf with the specified elements.
static <V extends ACell> SetLeaf<V>	SetLeaf.create(V item)
static <T extends ACell> ASet<T>	Sets.create(ACountable<T> source)	Creates a set of all the elements in the given data structure
static <V extends ACell> SetTree<V>	SetTree.create(Ref<V>[] elementRefs, int shift)	Create a SetTree given a number of element Refs to distribute among children.
static <T extends ACell> SignedData<T>	SignedData.create(ASignature sig, Ref<T> ref)	Creates a SignedData object with the given parameters.
static <T extends ACell> SignedData<T>	SignedData.create(AccountKey address, ASignature sig, Ref<T> ref)	Creates a SignedData object with the given parameters.
static <T extends ACell> VectorLeaf<T>	VectorLeaf.create(ACell[] elements, int offset, int length)	Creates a VectorLeaf with the given items
static <T extends ACell> VectorLeaf<T>	VectorLeaf.create(ACell[] elements, int offset, int length, AVector<T> prefix)	Creates a VectorLeaf with the given items appended to the specified tail
static <T extends ACell> VectorLeaf<T>	VectorLeaf.create(T[] things)
static <T extends ACell> AVector<T>	Vectors.create(ACell[] elements)	Create a vector from an array of elements.
static <T extends ACell> AVector<T>	Vectors.create(ACell[] elements, int offset, int length)	Creates a canonical AVector with the given elements
static <R extends ACell> AVector<R>	Vectors.create(ASequence<R> list)	Creates a Vector from the contents of an arbitrary sequence
static <R extends ACell, T extends ACell> AVector<R>	Vectors.create(Collection<?> elements)	Coerces a collection to a vector.
static <R extends ACell, T extends ACell> AVector<R>	Vectors.create(Collection<?> elements)	Coerces a collection to a vector.
static <T extends ACell> VectorTree<T>	VectorTree.create(ACell[] things, int offset, int length)	Create a TreeVector with the specified elements - things must have at least 32 elements (the minimum TreeVector size) - must be a whole multiple of 16 elements (complete chunks only)
static <T extends ACell> Ref<T>[]	Ref.createArray(T[] values)
static <T extends ACell> RefSoft<T>	RefSoft.createForHash(Hash hash)	Create a RefSoft with a Hash reference.
protected <R extends ACell> Ref<R>	AccountKey.createRef()
protected <R extends ACell> Ref<R>	ACell.createRef()	Creates a new Ref for this Cell
protected <R extends ACell> Ref<R>	ALongBlob.createRef()
protected <R extends ACell> Ref<R>	ASymbolic.createRef()
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.createRef(Ref<? extends K> keyRef, Ref<? extends V> valueRef)
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.createRef(Ref<? extends K> keyRef, Ref<? extends V> valueRef)
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.createWithShift(int shift, List<MapEntry<K,V>> entries)	Create a hashmap with the correct shift and given entries.
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.createWithShift(int shift, List<MapEntry<K,V>> entries)	Create a hashmap with the correct shift and given entries.
static <T extends ACell> AHashSet<T>	Sets.createWithShift(int shift, ArrayList<Ref<T>> values)
static <T extends ACell> T	Format.decodeMultiCell(Blob data)	Reads a cell from a Blob of data, allowing for non-embedded children following the first cell
static <T extends ACell> List<T>	Lists.empty()
static <K extends ACell, V extends ACell, R extends AHashMap<K, V>> R	Maps.empty()
static <K extends ACell, V extends ACell, R extends AHashMap<K, V>> R	Maps.empty()
static <T extends ACell> SetLeaf<T>	Sets.empty()
static <T extends ACell> AVector<T>	Vectors.empty()
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.emptyMap()
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.emptyMap()
static <K extends ACell, V extends ACell, R extends AMap<K, V>> Ref<R>	Maps.emptyRef()
static <K extends ACell, V extends ACell, R extends AMap<K, V>> Ref<R>	Maps.emptyRef()
static <T extends ACell> Ref<SetLeaf<T>>	Sets.emptyRef()
static <V extends ACell> SetLeaf<V>	SetLeaf.emptySet()
<R extends ACell> ASequence<R>	ASequence.flatMap(Function<? super T,? extends ASequence<R>> mapper)
<R extends ACell> AVector<R>	AVector.flatMap(Function<? super T,? extends ASequence<R>> mapper)
static <T extends ACell> RefSoft<T>	Ref.forHash(Hash hash)	Creates a RefSoft using a specific Hash.
static <T extends ACell> ASet<T>	Sets.fromCollection(Collection<T> source)	Creates a set of all the elements in the given data structure
static <T extends ACell> Ref<T>	Ref.get(T value)	Returns a direct Ref wrapping the given value.
<R extends ACell> AFn<R>	AccountStatus.getCallableFunction(Symbol sym)	Gets a callable function from the environment, or null if not callable
final <T extends ACell> T	ACell.getCanonical()	Gets the canonical representation of this Cell.
<R extends ACell> Ref<R>[]	ACell.getChildRefs()	Gets an array of child Refs for this Cell, in the same order as order accessible by getRef.
<R extends ACell> R	AccountStatus.getEnvironmentValue(Symbol symbol)	Gets the value in the Account's environment for the given symbol.
static <T extends ACell> Blob	SignedData.getMessageForRef(Ref<T> ref)
<R extends ACell> Ref<R>	AArrayBlob.getRef(int i)
<R extends ACell> Ref<R>	AccountStatus.getRef(int i)
final <R extends ACell> Ref<R>	ACell.getRef()	Gets the Ref for this Cell, creating a new direct reference if necessary
<R extends ACell> Ref<R>	ACell.getRef(int i)	Gets a numbered child Ref from within this Cell.
<R extends ACell> Ref<R>	Address.getRef(int i)
abstract <R extends ACell> Ref<R>	AIndex.getRef(int i)
<R extends ACell> Ref<R>	ALongBlob.getRef(int i)
abstract <R extends ACell> Ref<R>	AMapEntry.getRef(int i)
<R extends ACell> Ref<R>	ARecordGeneric.getRef(int index)
<R extends ACell> Ref<R>	ASymbolic.getRef(int i)
<R extends ACell> Ref<R>	BlobTree.getRef(int i)
static <R extends ACell> Ref<R>	Cells.getRef(ACell cell, int index)	Gets a Ref from a Cell by index
<R extends ACell> Ref<R>	Index.getRef(int i)
<R extends ACell> Ref<R>	List.getRef(int i)
<R extends ACell> Ref<R>	MapEntry.getRef(int i)
<R extends ACell> Ref<R>	MapLeaf.getRef(int i)
<R extends ACell> Ref<R>	MapTree.getRef(int i)
<R extends ACell> Ref<R>	PeerStatus.getRef(int i)
<R extends ACell> Ref<R>	SetTree.getRef(int i)
<R extends ACell> Ref<R>	SignedData.getRef(int i)
<R extends ACell> Ref<R>	StringShort.getRef(int i)
<R extends ACell> Ref<R>	StringTree.getRef(int i)
<R extends ACell> Ref<R>	Syntax.getRef(int i)
<R extends ACell> Ref<R>	VectorLeaf.getRef(int i)
<R extends ACell> Ref<R>	VectorTree.getRef(int i)
abstract <R extends ACell> ACollection<R>	ACollection.map(Function<? super T,? extends R> mapper)	Maps a function over a collection, applying it to each element in turn.
abstract <R extends ACell> AList<R>	AList.map(Function<? super T,? extends R> mapper)
abstract <R extends ACell> ASequence<R>	ASequence.map(Function<? super T,? extends R> mapper)
<R extends ACell> ASet<R>	ASet.map(Function<? super T,? extends R> mapper)
abstract <R extends ACell> AVector<R>	AVector.map(Function<? super T,? extends R> mapper)
<R extends ACell> AList<R>	List.map(Function<? super T,? extends R> mapper)
<R extends ACell> AVector<R>	MapEntry.map(Function<? super ACell,? extends R> mapper)
<R extends ACell> AVector<R>	VectorArray.map(Function<? super T,? extends R> mapper)
<R extends ACell> AVector<R>	VectorLeaf.map(Function<? super T,? extends R> mapper)
<R extends ACell> AVector<R>	VectorTree.map(Function<? super T,? extends R> mapper)
static final <T extends ACell> Ref<T>	Ref.nil()
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.none()
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.of(Object... kvs)
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.of(Object k, Object v)
static <T extends ACell> List<T>	List.of(Object... elements)
static <T extends ACell> AList<T>	Lists.of(Object... vals)
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.of(Object key, Object value)	Create a map entry, converting key and value to correct CVM types.
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.of(Object key, Object value)	Create a map entry, converting key and value to correct CVM types.
static <R extends AHashMap<K, V>, K extends ACell, V extends ACell> R	Maps.of(Object... keysAndValues)	Constructs a map with the given keys and values.
static <R extends AHashMap<K, V>, K extends ACell, V extends ACell> R	Maps.of(Object... keysAndValues)	Constructs a map with the given keys and values.
static <T extends ACell> ASet<T>	Sets.of(ACell... elements)
static <T extends ACell> ASet<T>	Sets.of(Object... elements)
static <T extends ACell> VectorArray<T>	VectorArray.of(Object... os)
static <T extends ACell> AVector<T>	Vectors.of(Object... elements)	Creates a vector with the given values.
static <T extends ACell> T	Cells.persist(T a)	Persist a cell in the current store
static <T extends ACell> T	Cells.persist(T a, AStore store)	Persist a cell in the given store
<R extends ACell> Ref<R>	Ref.persist()	Persists this Ref in the current store if not embedded and not already persisted.
<R extends ACell> Ref<R>	Ref.persist(Consumer<Ref<ACell>> noveltyHandler)	Persists this Ref in the current store if not embedded and not already persisted.
<R extends ACell> Ref<R>	Ref.persistShallow()	Persists a Ref shallowly in the current store.
<R extends ACell> Ref<R>	Ref.persistShallow(Consumer<Ref<ACell>> noveltyHandler)	Persists a Ref shallowly in the current store.
static <T extends ACell> T	Format.read(Blob blob)	Decodes a single Value from a Blob.
static <T extends ACell> T	Format.read(Blob blob, int offset)	Decodes a single Value from a Blob, starting at a given offset Assumes the presence of a tag.
static <T extends ACell> T	Format.read(String hexString)	Helper method to read a value encoded as a hex string
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.read(Blob b, int pos)
static <T extends ACell> List<T>	List.read(Blob b, int pos)	Reads a List from the specified Blob.
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.read(Blob b, int pos, long count)	Reads a MapLeaf from the provided Blob encoding.
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.read(Blob b, int pos, long count)	Reads a MapLeaf from the provided Blob encoding.
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.read(Blob b, int pos)	Read a Hashmap from a Blob.
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.read(Blob b, int pos)	Read a Hashmap from a Blob.
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.read(Blob b, int pos, long count)	Reads a ListMap from the provided Blob
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.read(Blob b, int pos, long count)	Reads a ListMap from the provided Blob
static <V extends ACell> SetLeaf<V>	SetLeaf.read(Blob b, int pos, long count)	Reads a MapLeaf from the provided ByteBuffer Assumes the header byte is already read.
static <T extends ACell> ASet<T>	Sets.read(Blob b, int pos)
static <V extends ACell> SetTree<V>	SetTree.read(Blob b, int pos, long count)	Reads a SetTree from the provided Blob encoding
static <T extends ACell> SignedData<T>	SignedData.read(Blob b, int pos, boolean includeKey)	Reads a SignedData instance from the given Blob encoding
static <T extends ACell> VectorLeaf<T>	VectorLeaf.read(long count, Blob b, int pos)	Reads a VectorLeaf from the provided Blob Assumes the header byte and count is already read.
static <T extends ACell> AVector<T>	Vectors.read(Blob b, int pos)	Reads a Vector for the specified Blob.
static <T extends ACell> VectorTree<T>	VectorTree.read(long count, Blob b, int pos)	Reads a VectorTree from the provided Blob Assumes the header byte and count is already checked.
static <T extends ACell> Ref<T>	Ref.readRaw(Blob b, int pos)	Reads a ref from the given Blob position.
static <T extends ACell> Ref<T>	Format.readRef(Blob b, int pos)	Reads a Ref or embedded Cell value from a Blob Converts Embedded Cells to Direct Refs automatically.
static <T extends ACell> AVector<T>	Vectors.repeat(T m, int count)
static <T extends ACell> List<T>	List.reverse(AVector<T> vector)	Creates a List containing the elements of the provided vector in reverse order
static <T extends ACell> SignedData<T>	SignedData.sign(AKeyPair keyPair, T value)	Create a SignedData by signing a value with the given key pair
static <T extends ACell> SignedData<T>	SignedData.signRef(AKeyPair keyPair, Ref<T> ref)	Signs a data value Ref with the given keypair.
static <T extends ACell> T	Cells.store(T a, AStore store)	Persist a cell in the given store
static <K extends ABlobLike<?>, V extends ACell> Index<K,V>	Index.unsafeCreate(long depth, MapEntry<K,V> entry, Ref<Index>[] entries, int mask, long count)
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.unsafeCreate(MapEntry<K,V>... items)	Creates a MapLeaf
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.unsafeCreate(MapEntry<K,V>... items)	Creates a MapLeaf
static <V extends ACell> SetLeaf<V>	SetLeaf.unsafeCreate(Ref<V>... refs)	Create a SetLeaf with raw element Refs.
static <V extends ACell> SetLeaf<V>	SetLeaf.unsafeCreate(V... elements)	Create a SetLeaf with raw elements.
static <T extends ACell> SetTree<T>	SetTree.unsafeCreate(Ref<AHashSet<T>>[] children, int shift, short mask, long count)
static <R extends ACell> R	Syntax.unwrapAll(ACell maybeSyntax)	Recursively unwraps a Syntax object
static <T extends ACell> T	Ref.update(T o, IRefFunction func)	Updates Refs in an arbitrary Cell
static <T extends ACell> Ref<T>[]	Ref.updateRefs(Ref<T>[] refs, IRefFunction func)	Updates an array of Refs with the given function.
static <R extends ACell> R	Ref.updateRefs(R a, IRefFunction func)
static <R extends ACell> List<R>	List.wrap(AVector<R> vector)	Wraps a Vector as a list (will reverse element order)
static <T extends ACell> VectorArray<T>	VectorArray.wrap(ACell[] arr)
static <T extends ACell> AVector<T>	Vectors.wrap(ACell[] elements)	Create a vector directly wrapping an array of cells.

Methods in convex.core.data that return ACell

Modifier and Type	Method	Description
ACell	Encoder.decode(Blob encoding)
static ACell[]	Format.decodeCells(Blob data)	Decodes an array of Cells packed in a Blob.
ACell	AccountStatus.get(Keyword key)
abstract ACell	ADataStructure.get(ACell key)	Get the value associated with a given key.
abstract ACell	ADataStructure.get(ACell key, ACell notFound)	Get the value associated with a given key.
abstract ACell	AMapEntry.get(long i)
final ACell	ARecord.get(ACell key)	Gets the record field content for a given key, or null if not found.
abstract ACell	ARecord.get(Keyword key)	Gets the record field content for a given key, or null if not found.
ACell	ARecordGeneric.get(Keyword key)
ACell	ASequence.get(ACell key, ACell notFound)
ACell	ASet.get(ACell key, ACell notFound)
ACell	MapEntry.get(long i)
ACell	PeerStatus.get(Keyword key)
ACell	SignedData.get(Keyword key)
ACell	AccountStatus.getController()	Get the controller for this Account
ACell	AccountStatus.getHolding(Address addr)
ACell[]	ARecord.getValuesArray()	Gets an array containing all values in this record, in format-defined key order.
protected abstract ACell	ACell.toCanonical()	Converts this Cell to a canonical version.
ACell	Index.toCanonical()
ACell	Keyword.toCanonical()
ACell	List.toCanonical()
ACell	MapLeaf.toCanonical()
ACell	Symbol.toCanonical()
ACell	Syntax.toCanonical()
protected ACell	VectorArray.toCanonical()
ACell	VectorLeaf.toCanonical()
ACell	VectorTree.toCanonical()
ACell[]	ACollection.toCellArray()	Converts this collection to a new Cell array
ACell[]	ASequence.toCellArray()	Converts this sequence to a new Cell array
static ACell[]	Cells.toCellArray(Object anyArray)	Converts any array to an ACell[] array.
ACell	AArrayBlob.updateRefs(IRefFunction func)
ACell	ACell.updateRefs(IRefFunction func)	Updates all Refs in this object using the given function.
ACell	Address.updateRefs(IRefFunction func)
ACell	ALongBlob.updateRefs(IRefFunction func)
ACell	ASymbolic.updateRefs(IRefFunction func)
ACell	StringShort.updateRefs(IRefFunction func)

Methods in convex.core.data that return types with arguments of type ACell

Modifier and Type	Method	Description
ASet<ACell>	Ref.addAllToSet(ASet<ACell> store)	Adds the value of this Ref and all non-embedded child values to a given set.
AVector<ACell>	AMapEntry.append(ACell value)
final AVector<ACell>	AMapEntry.appendChunk(AVector<ACell> chunk)
AMap<Keyword,ACell>	ARecord.assoc(ACell key, ACell value)
AMap<Keyword,ACell>	ARecord.assocEntry(MapEntry<Keyword,ACell> e)
AVector<ACell>	MapEntry.concat(ASequence<?> b)
final AMap<Keyword,ACell>	ARecord.dissoc(ACell key)
AMap<Keyword,ACell>	ARecord.dissoc(Keyword key)
AHashMap<Keyword,ACell>	ARecord.empty()
MapEntry<Keyword,ACell>	ARecord.entryAt(long i)
MapEntry<Keyword,ACell>	ARecordGeneric.entryAt(long i)
Set<Map.Entry<Keyword,ACell>>	ARecord.entrySet()
final VectorLeaf<ACell>	AMapEntry.getChunk(long offset)
Ref<ACell>	MapEntry.getElementRef(long i)
protected Ref<ACell>	MapEntry.getElementRefUnsafe(long i)
MapEntry<Keyword,ACell>	ARecord.getEntry(ACell k)
protected MapEntry<Keyword,ACell>	ARecord.getEntryByHash(Hash hash)
AHashMap<Symbol,ACell>	AccountStatus.getEnvironment()	Gets the Environment for this account.
Index<Address,ACell>	AccountStatus.getHoldings()	Gets the holdings for this account.
MapEntry<Keyword,ACell>	ARecord.getKeyRefEntry(Ref<ACell> keyRef)
AHashMap<ACell,ACell>	Syntax.getMeta()	Gets the metadata for this syntax object.
AHashMap<ACell,ACell>	Syntax.getMeta()	Gets the metadata for this syntax object.
AHashMap<Symbol,AHashMap<ACell,ACell>>	AccountStatus.getMetadata()	Gets the Metadata map for this Account
AHashMap<Symbol,AHashMap<ACell,ACell>>	AccountStatus.getMetadata()	Gets the Metadata map for this Account
AHashMap<ACell,ACell>	PeerStatus.getMetadata()	Gets the Metadata of this Peer
AHashMap<ACell,ACell>	PeerStatus.getMetadata()	Gets the Metadata of this Peer
Ref<ACell>	VectorArray.getRef(int i)
Iterator<ACell>	AMapEntry.iterator()
ListIterator<ACell>	AMapEntry.listIterator()
ListIterator<ACell>	AMapEntry.listIterator(long index)
AVector<ACell>	AMapEntry.next()
AVector<ACell>	AMapEntry.slice(long start, long end)
VectorLeaf<ACell>	MapEntry.toCanonical()
protected AHashMap<Keyword,ACell>	ARecord.toHashMap()	Converts this record to a HashMap
AVector<ACell>	MapEntry.toVector()
AVector<ACell>	ARecord.values()	Gets a vector of values for this Record, in format-determined order
AVector<ACell>	ARecordGeneric.values()

Methods in convex.core.data with parameters of type ACell

Modifier and Type	Method	Description
static Set<Ref<?>>	Refs.accumulateRefSet(ACell a)	Accumulates the set of all unique Refs in the given object.
AVector<ACell>	AMapEntry.append(ACell value)
abstract ADataStructure<E>	ADataStructure.assoc(ACell key, ACell value)	Associates a key with a value in this associative data structure.
abstract AHashMap<K,V>	AHashMap.assoc(ACell key, ACell value)
abstract AIndex<K,V>	AIndex.assoc(ACell key, ACell value)	Associates a blob key with a value in this data structure.
abstract AMap<K,V>	AMap.assoc(ACell key, ACell value)	Associates the given key with the specified value.
AMap<Keyword,ACell>	ARecord.assoc(ACell key, ACell value)
ASequence<T>	ASequence.assoc(ACell key, ACell value)
ASet<T>	ASet.assoc(ACell key, ACell value)
Index<K,V>	Index.assoc(ACell key, ACell value)
MapEntry<K,V>	MapEntry.assoc(long i, ACell a)
AHashMap<K,V>	MapLeaf.assoc(ACell key, ACell value)
MapTree<K,V>	MapTree.assoc(ACell key, ACell value)
static int	Cells.branchCount(ACell a)	Gets the number of Branches directly contained in a Cell (will be zero if the Cell is not a Ref container)
abstract ACollection<T>	ACollection.conj(ACell x)	Adds an element to this collection, according to the natural semantics of the collection
abstract ADataStructure<E>	ADataStructure.conj(ACell x)	Adds an element to this data structure, in the natural manner defined by the general data structure type.
AHashSet<T>	AHashSet.conj(ACell a)
abstract AList<T>	AList.conj(ACell x)	Adds an element to this list, in first position.
AMap<K,V>	AMap.conj(ACell x)	Adds a new map entry to this map.
abstract ASequence<T>	ASequence.conj(ACell value)	Adds an element to the sequence in the natural position
abstract ASet<T>	ASet.conj(ACell a)
final AVector<T>	AVector.conj(ACell value)
List<T>	List.conj(ACell value)	Prepends an element to the list in first position.
boolean	AHashSet.contains(ACell key)
abstract boolean	ASet.contains(ACell o)	Tests if this Set contains a given value
abstract boolean	ADataStructure.containsKey(ACell key)	Checks if the data structure contains the specified key
final boolean	AHashMap.containsKey(ACell key)
boolean	AIndex.containsKey(ACell key)
boolean	AMap.containsKey(ACell key)
boolean	ARecord.containsKey(ACell key)
boolean	ASequence.containsKey(ACell key)
boolean	ASet.containsKey(ACell key)
abstract boolean	AMap.containsValue(ACell value)	CHecks if this map contains the given value.
boolean	ARecord.containsValue(ACell value)
boolean	Index.containsValue(ACell value)
boolean	MapLeaf.containsValue(ACell value)
boolean	MapTree.containsValue(ACell value)
static <T extends ACell> List<T>	List.create(ACell... args)	Creates a list wrapping the given array.
static <R extends AHashMap<K, V>, K extends ACell, V extends ACell> R	Maps.create(ACell[] keysAndValues)	Constructs a map with the given keys and values.
static Syntax	Syntax.create(ACell value)	Wraps a value as a Syntax Object with empty metadata.
static Syntax	Syntax.create(ACell value, AHashMap<ACell,ACell> meta)	Wraps a value as a Syntax Object, adding the given new metadata
static <T extends ACell> VectorLeaf<T>	VectorLeaf.create(ACell[] elements, int offset, int length)	Creates a VectorLeaf with the given items
static <T extends ACell> VectorLeaf<T>	VectorLeaf.create(ACell[] elements, int offset, int length, AVector<T> prefix)	Creates a VectorLeaf with the given items appended to the specified tail
static <T extends ACell> VectorLeaf<T>	VectorLeaf.create(T[] things)
static <T extends ACell> AVector<T>	Vectors.create(ACell[] elements)	Create a vector from an array of elements.
static <T extends ACell> AVector<T>	Vectors.create(ACell[] elements, int offset, int length)	Creates a canonical AVector with the given elements
static <T extends ACell> VectorTree<T>	VectorTree.create(ACell[] things, int offset, int length)	Create a TreeVector with the specified elements - things must have at least 32 elements (the minimum TreeVector size) - must be a whole multiple of 16 elements (complete chunks only)
static <T extends ACell> Ref<T>[]	Ref.createArray(T[] values)
static Syntax	Syntax.createUnchecked(ACell value, AHashMap<ACell,ACell> meta)
abstract AHashMap<K,V>	AHashMap.dissoc(ACell key)
final AIndex<K,V>	AIndex.dissoc(ACell key)
abstract AMap<K,V>	AMap.dissoc(ACell key)	Dissociates a key from this map, returning an updated map if the key was removed, or the same unchanged map if the key is not present.
final AMap<Keyword,ACell>	ARecord.dissoc(ACell key)
MapLeaf<K,V>	MapLeaf.dissoc(ACell key)
AHashMap<K,V>	MapTree.dissoc(ACell key)
Blob	Encoder.encode(ACell a)
static Blob	Format.encodedBlob(ACell o)	Gets the encoded Blob for an object in canonical message format
static String	Format.encodedString(ACell cell)	Gets a hex String representing an object's encoding
static Blob	Format.encodeMultiCell(ACell a, boolean everything)	Encode a Cell completely in multi-cell message format.
boolean	ABlob.equals(ACell o)	Determines if this Blob is equal to another Object.
boolean	AccountStatus.equals(ACell o)
abstract boolean	ACell.equals(ACell a)	Checks for equality with another Cell.
boolean	Address.equals(ACell o)
boolean	ARecordGeneric.equals(ACell a)
final boolean	AString.equals(ACell o)
final boolean	AVector.equals(ACell a)
static boolean	Cells.equals(ACell a, ACell b)	Equality method allowing for nulls
boolean	Index.equals(ACell a)
boolean	Keyword.equals(ACell other)
boolean	List.equals(ACell o)
boolean	MapLeaf.equals(ACell a)
boolean	MapTree.equals(ACell a)
boolean	PeerStatus.equals(ACell a)
boolean	SetLeaf.equals(ACell a)
boolean	SetTree.equals(ACell a)
boolean	SignedData.equals(ACell o)
boolean	Symbol.equals(ACell o)
boolean	Syntax.equals(ACell o)
static int	Format.estimateEncodingSize(ACell cell)	Estimate the encoding size of a Cell value.
ASet<T>	AHashSet.exclude(ACell a)
abstract ASet<T>	ASet.exclude(ACell a)	Updates the set to exclude the given element
SetLeaf<T>	SetLeaf.exclude(ACell key)
AHashSet<T>	SetTree.exclude(ACell key)
protected static boolean	ACell.genericEquals(ACell a, ACell b)	Generic Cell equality, use only if better implementation not available.
abstract ACell	ADataStructure.get(ACell key)	Get the value associated with a given key.
abstract ACell	ADataStructure.get(ACell key, ACell notFound)	Get the value associated with a given key.
final CVMBool	AHashSet.get(ACell key)
final V	AIndex.get(ACell key)
abstract V	AMap.get(ACell key)
final V	AMap.get(ACell key, ACell notFound)	Gets the value at a specified key, or returns the fallback value if not found
final ACell	ARecord.get(ACell key)	Gets the record field content for a given key, or null if not found.
T	ASequence.get(ACell key)	Gets the element at the specified key
ACell	ASequence.get(ACell key, ACell notFound)
CVMBool	ASet.get(ACell key)
ACell	ASet.get(ACell key, ACell notFound)
static Hash	Hash.get(ACell value)	Computes the Hash for any ACell value.
V	MapLeaf.get(ACell key)
V	MapTree.get(ACell key)
static ABlobLike<CVMLong>	Cells.getEncoding(ACell a)
static int	Format.getEncodingLength(ACell value)
MapEntry<K,V>	AIndex.getEntry(ACell key)
abstract MapEntry<K,V>	AMap.getEntry(ACell k)	Gets the MapEntry for the given key
MapEntry<Keyword,ACell>	ARecord.getEntry(ACell k)
MapEntry<K,V>	MapLeaf.getEntry(ACell k)
MapEntry<K,V>	MapTree.getEntry(ACell k)
static Hash	Cells.getHash(ACell a)	Gets the Hash (Value ID of a cell)
static long	ACell.getMemorySize(ACell a)	Gets the Memory Size of a Cell, computing it if required.
static <R extends ACell> Ref<R>	Cells.getRef(ACell cell, int index)	Gets a Ref from a Cell by index
abstract Ref<T>	ASet.getValueRef(ACell k)	Gets the Ref in the Set for a given value, or null if not found
Ref<T>	SetLeaf.getValueRef(ACell k)
Ref<T>	SetTree.getValueRef(ACell k)
SetTree<T>	SetTree.include(ACell value)
static boolean	Format.isCanonical(ACell o)	Returns true if the object is a canonical data object.
static boolean	Cells.isCompletelyEncoded(ACell a)	Checks if a Cell is completely encoded, i.e.
static boolean	Cells.isCVM(ACell a)	Checks if a Cell is a valid CVM value
static boolean	Format.isEmbedded(ACell cell)	Determines if an object should be embedded directly in the encoding rather than referenced with a Ref / hash.
static boolean	Cells.isValue(ACell a)	Checks if a Cell is a first class value
static Syntax	Syntax.mergeMeta(ACell original, Syntax additional)	Merge metadata into a Cell, after wrapping as a Syntax Object
static <T extends ACell> ASet<T>	Sets.of(ACell... elements)
static Syntax	Syntax.of(ACell value)	Wraps a value as a Syntax Object with empty metadata.
static String	Refs.printMissingTree(ACell value)
static void	Refs.printMissingTree(StringBuilder sb, ACell value)	Utility function to locate missing data
static int	Cells.refCount(ACell a)	Gets the number of Refs directly contained in a Cell (will be zero if the Cell is not a Ref container)
static long	Cells.storageSize(ACell a)	Get the full storage size of a value, including size of an embedded encoding
static long	Refs.totalRefCount(ACell a)	Counts the total number of Refs contained in a data object recursively, including the given cell.
static long	Refs.uniqueRefCount(ACell a)	Counts the number of logically unique Refs for a Cell, i.e.
static <V extends ACell> SetLeaf<V>	SetLeaf.unsafeCreate(V... elements)	Create a SetLeaf with raw elements.
static <R> R	Syntax.unwrap(ACell x)	Unwraps a Syntax Object to get the underlying value.
static <R extends ACell> R	Syntax.unwrapAll(ACell maybeSyntax)	Recursively unwraps a Syntax object
static void	Cells.visitBranches(ACell a, Consumer<ACell> visitor)	Visit all non-embedded branches from a Cell.
static void	Cells.visitBranchRefs(ACell a, Consumer<Ref<?>> visitor)	Visit all non-embedded branches from a Cell.
AccountStatus	AccountStatus.withController(ACell newController)
AccountStatus	AccountStatus.withHolding(Address addr, ACell value)
static <T extends ACell> VectorArray<T>	VectorArray.wrap(ACell[] arr)
static <T extends ACell> AVector<T>	Vectors.wrap(ACell[] elements)	Create a vector directly wrapping an array of cells.
static int	Format.write(byte[] bs, int pos, ACell cell)	Writes a cell encoding to a byte array, preceded by the appropriate tag

Method parameters in convex.core.data with type arguments of type ACell

Modifier and Type	Method	Description
protected void	ARecord.accumulateEntrySet(Set<Map.Entry<Keyword,ACell>> h)
protected void	ARecord.accumulateValues(List<ACell> al)
ASet<ACell>	Ref.addAllToSet(ASet<ACell> store)	Adds the value of this Ref and all non-embedded child values to a given set.
boolean	AMapEntry.allMatch(Predicate<? super ACell> pred)
static <T extends ACell> T	Cells.announce(T a, Consumer<Ref<ACell>> noveltyHandler)	Announces a Cell, reporting as novelty any cells that have not been previously announced
boolean	AMapEntry.anyMatch(Predicate<? super ACell> pred)
final AVector<ACell>	AMapEntry.appendChunk(AVector<ACell> chunk)
AMap<Keyword,ACell>	ARecord.assocEntry(MapEntry<Keyword,ACell> e)
long	AMapEntry.commonPrefixLength(AVector<ACell> b)
final boolean	AMap.containsKeyRef(Ref<ACell> ref)
static PeerStatus	PeerStatus.create(Address controller, long stake, AHashMap<ACell,ACell> metadata)
static PeerStatus	PeerStatus.create(Address controller, long stake, AHashMap<ACell,ACell> metadata)
static Syntax	Syntax.create(ACell value, AHashMap<ACell,ACell> meta)	Wraps a value as a Syntax Object, adding the given new metadata
static Syntax	Syntax.create(ACell value, AHashMap<ACell,ACell> meta)	Wraps a value as a Syntax Object, adding the given new metadata
static Syntax	Syntax.createUnchecked(ACell value, AHashMap<ACell,ACell> meta)
static Syntax	Syntax.createUnchecked(ACell value, AHashMap<ACell,ACell> meta)
static void	Format.decodeCells(HashMap<Hash,ACell> acc, Blob data)	Decode encoded non-embedded Cells into an accumulator HashMap
static Blob	Format.encodeCells(List<ACell> cells)	Encodes a flat list of cells in order specified in multi-cell format
static Blob	Format.encodeDelta(List<ACell> cells)	Encode a list of cells as a delta message.
boolean	MapEntry.equals(AVector<? super ACell> o)
void	AMapEntry.forEach(Consumer<? super ACell> action)
void	ARecord.forEach(BiConsumer<? super Keyword,? super ACell> action)
MapEntry<K,V>	AIndex.getKeyRefEntry(Ref<ACell> ref)
abstract MapEntry<K,V>	AMap.getKeyRefEntry(Ref<ACell> ref)	Get an entry given a Ref to the key value.
MapEntry<Keyword,ACell>	ARecord.getKeyRefEntry(Ref<ACell> keyRef)
MapEntry<K,V>	MapLeaf.getKeyRefEntry(Ref<ACell> ref)
MapEntry<K,V>	MapTree.getKeyRefEntry(Ref<ACell> ref)
<R extends ACell> AVector<R>	MapEntry.map(Function<? super ACell,? extends R> mapper)
Syntax	Syntax.mergeMeta(AHashMap<ACell,ACell> additionalMetadata)	Merges metadata into this syntax object, overriding existing metadata
Syntax	Syntax.mergeMeta(AHashMap<ACell,ACell> additionalMetadata)	Merges metadata into this syntax object, overriding existing metadata
<R extends ACell> Ref<R>	Ref.persist(Consumer<Ref<ACell>> noveltyHandler)	Persists this Ref in the current store if not embedded and not already persisted.
<R extends ACell> Ref<R>	Ref.persistShallow(Consumer<Ref<ACell>> noveltyHandler)	Persists a Ref shallowly in the current store.
<R> R	MapEntry.reduce(BiFunction<? super R,? super ACell,? extends R> func, R value)
<R> R	ARecord.reduceEntries(BiFunction<? super R,MapEntry<Keyword,ACell>,? extends R> func, R initial)
<R> R	ARecord.reduceValues(BiFunction<? super R,? super ACell,? extends R> func, R initial)
static void	Cells.visitBranches(ACell a, Consumer<ACell> visitor)	Visit all non-embedded branches from a Cell.
void	MapEntry.visitElementRefs(Consumer<Ref<ACell>> f)
AccountStatus	AccountStatus.withEnvironment(AHashMap<Symbol,ACell> newEnvironment)
Syntax	Syntax.withMeta(AHashMap<ACell,ACell> newMetadata)	Replaces metadata on this Syntax Object.
Syntax	Syntax.withMeta(AHashMap<ACell,ACell> newMetadata)	Replaces metadata on this Syntax Object.
AccountStatus	AccountStatus.withMetadata(AHashMap<Symbol,AHashMap<ACell,ACell>> newMeta)
AccountStatus	AccountStatus.withMetadata(AHashMap<Symbol,AHashMap<ACell,ACell>> newMeta)
PeerStatus	PeerStatus.withPeerData(AHashMap<ACell,ACell> newMeta)
PeerStatus	PeerStatus.withPeerData(AHashMap<ACell,ACell> newMeta)
protected abstract ARecord	ARecordGeneric.withValues(AVector<ACell> newValues)	Updates the record with a new set of values.

Constructor parameters in convex.core.data with type arguments of type ACell

Modifier	Constructor	Description
protected	ARecordGeneric(RecordFormat format, AVector<ACell> values)

Uses of ACell in convex.core.data.impl

Classes in convex.core.data.impl with type parameters of type ACell

Modifier and Type	Class	Description
class	ADerivedSet<T extends ACell,K extends ACell,V extends ACell>	Abstract base class for non-canonical sets derived off maps Useful for cases where we want a Set instance, but don't want to construct a whole new data structure
class	ADerivedSet<T extends ACell,K extends ACell,V extends ACell>	Abstract base class for non-canonical sets derived off maps Useful for cases where we want a Set instance, but don't want to construct a whole new data structure
class	ADerivedSet<T extends ACell,K extends ACell,V extends ACell>	Abstract base class for non-canonical sets derived off maps Useful for cases where we want a Set instance, but don't want to construct a whole new data structure
class	KeySet<K extends ACell,V extends ACell>
class	KeySet<K extends ACell,V extends ACell>

Subclasses of ACell in convex.core.data.impl

Modifier and Type	Class	Description
class	ADerivedSet<T extends ACell,K extends ACell,V extends ACell>	Abstract base class for non-canonical sets derived off maps Useful for cases where we want a Set instance, but don't want to construct a whole new data structure
class	KeySet<K extends ACell,V extends ACell>
class	ZeroBlob	Blob filled with all zeros.

Methods in convex.core.data.impl with type parameters of type ACell

Modifier and Type	Method	Description
static <K extends ACell, V extends ACell> KeySet<K,V>	KeySet.create(AHashMap<K,V> map)
static <K extends ACell, V extends ACell> KeySet<K,V>	KeySet.create(AHashMap<K,V> map)

Methods in convex.core.data.impl with parameters of type ACell

Modifier and Type	Method	Description
ASet<K>	KeySet.conj(ACell a)
boolean	KeySet.contains(ACell o)
boolean	KeySet.equals(ACell a)
ASet<K>	KeySet.exclude(ACell a)
Ref<K>	KeySet.getValueRef(ACell k)

Uses of ACell in convex.core.data.prim

Subclasses of ACell in convex.core.data.prim

Modifier and Type	Class	Description
class	AInteger	Abstract base class for CVM Integer values
class	ANumeric	BAse class for CVM numeric types
class	APrimitive	Abstract base class for CVM primitive values.
final class	CVMBigInteger	Arbitrary precision Integer implementation for the CVM.
final class	CVMBool	Class for CVM Boolean types.
final class	CVMChar	Class for CVM Character values.
final class	CVMDouble	Class for CVM double floating-point values.
final class	CVMLong	Class for CVM long values.

Methods in convex.core.data.prim with type parameters of type ACell

Modifier and Type	Method	Description
<R extends ACell> Ref<R>	APrimitive.getRef(int i)
<R extends ACell> Ref<R>	CVMBigInteger.getRef(int i)
<R extends ACell> Ref<R>	CVMBool.getRef(int i)

Methods in convex.core.data.prim that return ACell

Modifier and Type	Method	Description
ACell	CVMBool.not()
static ACell	CVMBool.parse(String text)
ACell	APrimitive.toCanonical()
ACell	APrimitive.updateRefs(IRefFunction func)
ACell	CVMBool.updateRefs(IRefFunction func)

Methods in convex.core.data.prim with parameters of type ACell

Modifier and Type	Method	Description
boolean	CVMBigInteger.equals(ACell a)
boolean	CVMBool.equals(ACell a)
boolean	CVMChar.equals(ACell a)
boolean	CVMDouble.equals(ACell a)
boolean	CVMLong.equals(ACell c)

Uses of ACell in convex.core.data.type

Classes in convex.core.data.type with type parameters of type ACell

Modifier and Type	Class	Description
class	AStandardType<T extends ACell>	Base type for standard types mapped directly to a branch of ACell hierarchy

Methods in convex.core.data.type that return ACell

Modifier and Type	Method	Description
ACell	Any.defaultValue()
abstract ACell	AType.defaultValue()	Gets the default value for this type.
ACell	Nil.defaultValue()
ACell	Any.implicitCast(ACell a)
abstract ACell	AType.implicitCast(ACell a)	Gets the default value for this type.
ACell	Nil.implicitCast(ACell a)

Methods in convex.core.data.type that return types with arguments of type ACell

Modifier and Type	Method	Description
Class<? extends ACell>	Any.getJavaClass()
abstract Class<? extends ACell>	AType.getJavaClass()	Gets the Java common base class for all instances of this type.
Class<? extends ACell>	Nil.getJavaClass()
Class<? extends ACell>	Number.getJavaClass()

Methods in convex.core.data.type with parameters of type ACell

Modifier and Type	Method	Description
boolean	AddressType.check(ACell value)
boolean	Any.check(ACell value)
boolean	AStandardType.check(ACell value)
abstract boolean	AType.check(ACell value)	Checks if a value is an instance of this Type.
boolean	Blob.check(ACell value)
boolean	Boolean.check(ACell value)
boolean	CharacterType.check(ACell value)
boolean	Collection.check(ACell value)
boolean	Countable.check(ACell value)
boolean	DataStructure.check(ACell value)
boolean	Double.check(ACell value)
boolean	Function.check(ACell value)
boolean	IndexType.check(ACell value)
boolean	Integer.check(ACell value)
boolean	KeywordType.check(ACell value)
boolean	List.check(ACell value)
boolean	Long.check(ACell value)
boolean	Map.check(ACell value)
boolean	Nil.check(ACell value)
boolean	Number.check(ACell value)
boolean	OpCode.check(ACell value)
boolean	Record.check(ACell value)
boolean	Sequence.check(ACell value)
boolean	Set.check(ACell value)
boolean	StringType.check(ACell value)
boolean	SymbolType.check(ACell value)
boolean	SyntaxType.check(ACell value)
boolean	Vector.check(ACell value)
static AType	Types.get(ACell data)
Address	AddressType.implicitCast(ACell a)
ACell	Any.implicitCast(ACell a)
T	AStandardType.implicitCast(ACell a)
abstract ACell	AType.implicitCast(ACell a)	Gets the default value for this type.
ABlob	Blob.implicitCast(ACell a)
CVMBool	Boolean.implicitCast(ACell a)
CVMChar	CharacterType.implicitCast(ACell a)
ACollection<?>	Collection.implicitCast(ACell a)
ACountable<?>	Countable.implicitCast(ACell a)
ADataStructure<?>	DataStructure.implicitCast(ACell a)
CVMDouble	Double.implicitCast(ACell a)
AFn	Function.implicitCast(ACell a)
AIndex	IndexType.implicitCast(ACell a)
AInteger	Integer.implicitCast(ACell a)
Keyword	KeywordType.implicitCast(ACell a)
AList<?>	List.implicitCast(ACell a)
CVMLong	Long.implicitCast(ACell a)
AMap	Map.implicitCast(ACell a)
ACell	Nil.implicitCast(ACell a)
ANumeric	Number.implicitCast(ACell a)
AOp	OpCode.implicitCast(ACell a)
ARecord	Record.implicitCast(ACell a)
ASequence<?>	Sequence.implicitCast(ACell a)
ASet<?>	Set.implicitCast(ACell a)
AString	StringType.implicitCast(ACell a)
Symbol	SymbolType.implicitCast(ACell a)
Syntax	SyntaxType.implicitCast(ACell a)
AVector	Vector.implicitCast(ACell a)

Uses of ACell in convex.core.data.util

Classes in convex.core.data.util with type parameters of type ACell

Modifier and Type	Class	Description
class	SequenceSpliterator<T extends ACell>
class	VectorBuilder<T extends ACell>	Similar to Java StringBuilder designed for concatenating multiple small Vectors to produce a larger Vector.

Fields in convex.core.data.util declared as ACell

Modifier and Type	Field	Description
protected final ACell[]	VectorBuilder.tail	Accumulator array for up to a single chunk worth of cells

Uses of ACell in convex.core.exceptions

Methods in convex.core.exceptions with type parameters of type ACell

Modifier and Type	Method	Description
<T extends ACell> SignedData<T>	BadSignatureException.getSignature()

Uses of ACell in convex.core.lang

Classes in convex.core.lang with type parameters of type ACell

Modifier and Type	Class	Description
class	AFn<T extends ACell>	Base class for functions expressed as values "You know what's web-scale? The Web.
class	AOp<T extends ACell>	Abstract base class for CVM operations "...that was the big revelation to me when I was in graduate school—when I finally understood that the half page of code on the bottom of page 13 of the Lisp 1.5 manual was Lisp in itself.
interface	IFn<T extends ACell>	Interface for invokable objects with function interface.

Subclasses of ACell in convex.core.lang

Modifier and Type	Class	Description
class	AFn<T extends ACell>	Base class for functions expressed as values "You know what's web-scale? The Web.
class	AOp<T extends ACell>	Abstract base class for CVM operations "...that was the big revelation to me when I was in graduate school—when I finally understood that the half page of code on the bottom of page 13 of the Lisp 1.5 manual was Lisp in itself.

Fields in convex.core.lang with type parameters of type ACell

Modifier and Type	Field	Description
static final CoreFn<ADataStructure<ACell>>	Core.ASSOC
static final CoreFn<ACell>	Core.ASSOC_IN
static final CoreFn<ACell>	Core.CALL_STAR
static final CoreFn<AOp<ACell>>	Core.COMPILE
static final CoreFn<ASequence<ACell>>	Core.CONCAT
static final CoreFn<ADataStructure<ACell>>	Core.CONJ
static final CoreFn<AList<ACell>>	Core.CONS
static final HashMap<Symbol,ACell>	Core.CORE_FORMS	Mapping from implicit symbols like #%count to core definitions
static final CoreFn<ASet<ACell>>	Core.DIFFERENCE
static final CoreFn<ASet<ACell>>	Core.DISJ
static final CoreFn<ACell>	Core.EMPTY
static final AVector<ACell>	Context.EMPTY_BINDINGS
static final AHashMap<Symbol,ACell>	Core.ENVIRONMENT	Default initial environment metadata importing core namespace
static final CoreFn<ACell>	Core.EVAL
static final CoreFn<ACell>	Core.EVAL_AS
static final CoreFn<ACell>	Core.EXPAND
static final CoreFn<ACell>	Core.FIRST
static final CoreFn<ACell>	Core.GET
static final CoreFn<ACell>	Core.GET_HOLDING
static final CoreFn<ACell>	Core.GET_IN
static final CoreFn<ACell>	Compiler.INITIAL_EXPANDER	Initial expander used for expansion of forms prior to compilation.
static final AFn<ACell>	Core.INITIAL_EXPANDER
static final CoreFn<ASet<ACell>>	Core.INTERSECTION
static final CoreFn<ADataStructure<ACell>>	Core.INTO
static final CoreFn<AVector<ACell>>	Core.KEYS
static final CoreFn<ACell>	Core.LAST
static final CoreFn<AList<ACell>>	Core.LIST
static final CoreFn<ACell>	Core.LOOKUP
static final CoreFn<AHashMap<ACell,ACell>>	Core.MERGE
static final CoreFn<AHashMap<ACell,ACell>>	Core.MERGE
static final CoreFn<AHashMap<ACell,ACell>>	Core.META
static final CoreFn<AHashMap<ACell,ACell>>	Core.META
static final AHashMap<Symbol,AHashMap<ACell,ACell>>	Core.METADATA	Default initial core metadata
static final AHashMap<Symbol,AHashMap<ACell,ACell>>	Core.METADATA	Default initial core metadata
static final CoreFn<ASequence<ACell>>	Core.NEXT
static final CoreFn<ACell>	Core.NTH
static final CoreFn<ACell>	Core.QUERY_AS
static final CoreFn<ACell>	Core.QUOTE	Expander used for expansion of `quote` forms.
static final CoreFn<ACell>	Core.REDUCE
static final CoreFn<ACell>	Core.REDUCED
static final CoreFn<AVector<ACell>>	Core.REVERSE
static final CoreFn<ACell>	Core.SECOND
static final CoreFn<ASet<ACell>>	Core.SET
static final CoreFn<ACell>	Core.SET_CONTROLLER
static final CoreFn<ACell>	Core.SET_HOLDING
static final CoreFn<ACell>	Core.SET_PARENT
static final CoreFn<ASequence<ACell>>	Core.SLICE
static final CoreFn<ACell>	Core.UNDEF_STAR
static final CoreFn<ASet<ACell>>	Core.UNION
static final CoreFn<ACell>	Core.UNSYNTAX
static final CoreFn<AVector<ACell>>	Core.VALUES
static final CoreFn<AVector<ACell>>	Core.VEC
static final CoreFn<AVector<ACell>>	Core.VECTOR

Methods in convex.core.lang with type parameters of type ACell

Modifier and Type	Method	Description
static <T extends ACell> Boolean	RT.allEqual(T[] values)	Returns true if all elements in an array are equal.
static <R extends ACell> ADataStructure<R>	RT.assoc(ADataStructure<R> coll, ACell key, ACell value)	Associates a key position with a given value in an associative data structure
static <T extends ACell> AFn<T>	RT.castFunction(ACell a)	Coerces an argument to a function interface.
static <T extends ACell> ASet<T>	RT.castSet(ACell o)	Converts any collection to a set
static <T extends ACell> AVector<T>	RT.castVector(ACell o)	Converts any countable data structure to a vector.
static <T extends ACell> AList<T>	RT.cons(T x, ASequence<?> xs)	Prepends an element to a sequential data structure to create a new list.
static <T extends ACell> AList<T>	RT.cons(T x, T y, ACell xs)	Prepends two elements to a sequential data structure.
static <T extends ACell> AList<T>	RT.cons(T x, T y, T z, ACell xs)	Prepends three elements to a sequential data structure.
static <T extends ACell> T	RT.cvm(Object o)	Converts a Java value to a CVM type.
static <V extends ACell> ABlobLike<V>	RT.ensureBlobLike(ACell a)
static <E extends ACell> ACountable<E>	RT.ensureCountable(ACell a)	Casts to an ACountable instance
static <E extends ACell> ADataStructure<E>	RT.ensureDataStructure(ACell a)	Casts to an ADataStructure instance
static <T extends ACell> AFn<T>	RT.ensureFunction(ACell a)	Ensure the argument is a valid CVM function.
static <K extends ACell, V extends ACell> AHashMap<K,V>	RT.ensureHashMap(ACell a)	Casts the argument to a hashmap.
static <K extends ACell, V extends ACell> AHashMap<K,V>	RT.ensureHashMap(ACell a)	Casts the argument to a hashmap.
static <K extends ACell, V extends ACell> AMap<K,V>	RT.ensureMap(ACell a)	Converts the argument to a non-null Map.
static <K extends ACell, V extends ACell> AMap<K,V>	RT.ensureMap(ACell a)	Converts the argument to a non-null Map.
static <K extends ACell, V extends ACell> MapEntry<K,V>	RT.ensureMapEntry(ACell x)	Converts an object to a map entry.
static <K extends ACell, V extends ACell> MapEntry<K,V>	RT.ensureMapEntry(ACell x)	Converts an object to a map entry.
static <T extends ACell> ASequence<T>	RT.ensureSequence(ACell o)	Ensures argument is a sequence data structure.
static <T extends ACell> ASet<T>	RT.ensureSet(ACell a)	Ensures the value is a Set.
static <T extends ACell> AVector<T>	RT.ensureVector(ACell o)	Ensures argument is a Vector data structure.
<T extends ACell> Context	Context.exec(AOp<T> op)	Executes an op as a top level instruction (no local bindings)
<R extends ACell> R	Context.getResult()	Gets the result from this context.
static <R extends ACell> AVector<R>	RT.keys(ACell a)	Returns a Vector of keys of a Map, or null if the object is not a Map WARNING: Potentially O(n) in size of Map
<T extends ACell> T	Context.lookupValue(String symName)	Looks up value for the given symbol in this context
static <T extends ACell> T	RT.nth(ACell o, long i)	Gets the nth element from a sequential collection.
static <T extends ACell> T	RT.nth(Object o, long i)	Variant of nth that also handles Java Arrays.
static <T extends ACell> AOp<T>	Ops.read(Blob b, int pos, byte opCode)	Reads an Op from the given Blob.
static <R extends ACell> R	Reader.read(String source)	Parses an expression and returns a canonical Cell representing a form
static <T extends ACell> ASequence<T>	RT.sequence(ACell o)	Converts any collection of cells into a Sequence data structure.
static <R extends ACell> AVector<R>	RT.values(ACell a)	Returns the vector of values of a map, or null if the object is not a map
static <T extends ACell> AVector<T>	RT.vec(ACollection<T> coll)	Converts any collection to a vector.
static <T extends ACell> AVector<T>	RT.vec(Object o)	Converts any data structure to a vector

Methods in convex.core.lang that return ACell

Modifier and Type	Method	Description
static ACell	RT.get(ADataStructure<?> coll, ACell key)	Gets an element from a data structure using the given key.
static ACell	RT.get(ADataStructure<?> coll, ACell key, ACell notFound)	Gets an element from a data structure using the given key.
ACell	Context.getErrorCode()	Gets the error code of this context's return value
protected ACell	Context.ChainState.getScope()
ACell	Context.getScope()	Gets the scope of the currently executing context.
ACell	Context.lookupValue(Address address, Symbol sym)	Looks up value for the given symbol in this context
ACell	Context.lookupValue(Symbol sym)	Looks up value for the given symbol in this context
static ACell	RT.max(ACell[] values)	Gets the minimum of a set of numeric values
static ACell	RT.max(ACell a, ACell b)	Gets the minimum of two numeric values
static ACell	RT.min(ACell[] values)	Gets the minimum of a set of numeric values
static ACell	RT.min(ACell a, ACell b)	Gets the minimum of two numeric values
static ACell	Core.read(Blob b, int pos)	Read a Core definition from an encoding
static ACell	Reader.read(Reader source)	Parses an expression and returns a form as an Object
static ACell	Reader.readResource(String path)
static ACell	Reader.readResourceAsData(String path)
static ACell	RT.signum(ACell a)	Gets the signum of a numeric value
ACell	AOp.toCanonical()

Methods in convex.core.lang that return types with arguments of type ACell

Modifier and Type	Method	Description
static AList<ACell>	Code.cnsUpdate(Symbol name, Address addr)	Create code for a CNS update call
AHashMap<Symbol,ACell>	Context.getEnvironment()	Gets the current Environment
Index<Address,ACell>	Context.getHoldings()	Gets the holdings map for the current account.
AVector<ACell>	Context.getLocalBindings()
AVector<AVector<ACell>>	Context.getLog()	Gets the log map for the current context.
AHashMap<Symbol,AHashMap<ACell,ACell>>	Context.ChainState.getMetadata()
AHashMap<Symbol,AHashMap<ACell,ACell>>	Context.ChainState.getMetadata()
AHashMap<Symbol,AHashMap<ACell,ACell>>	Context.getMetadata()	Gets the metadata for the current Account
AHashMap<Symbol,AHashMap<ACell,ACell>>	Context.getMetadata()	Gets the metadata for the current Account
MapEntry<Symbol,ACell>	Context.lookupDynamicEntry(Address address, Symbol sym)	Looks up an environment entry for a specific address without consuming juice.
AFn<ACell>	Context.lookupExpander(ACell form)	Looks up an expander from a form in this context
AHashMap<ACell,ACell>	Context.lookupMeta(Address address, Symbol sym)	Looks up Metadata for the given symbol in this context
AHashMap<ACell,ACell>	Context.lookupMeta(Address address, Symbol sym)	Looks up Metadata for the given symbol in this context
AHashMap<ACell,ACell>	Context.lookupMeta(Symbol sym)	Looks up Metadata for the given symbol in this context
AHashMap<ACell,ACell>	Context.lookupMeta(Symbol sym)	Looks up Metadata for the given symbol in this context
static AList<ACell>	Reader.readAll(String source)	Parses an String to returns a list of raw forms

Methods in convex.core.lang with parameters of type ACell

Modifier and Type	Method	Description
static APrimitive	RT.abs(ACell a)	Gets the absolute value of a numeric value.
Context	Context.actorCall(ACell target, long offer, ACell functionName, ACell... args)	Executes a call to an Actor.
Context	Context.actorCall(ACell target, long offer, String functionName, ACell... args)	Executes a call to an Actor.
static <T extends ACell> Boolean	RT.allEqual(T[] values)	Returns true if all elements in an array are equal.
static <R extends ACell> ADataStructure<R>	RT.assoc(ADataStructure<R> coll, ACell key, ACell value)	Associates a key position with a given value in an associative data structure
static boolean	RT.bool(ACell a)	Converts any CVM value to a boolean value.
static Address	RT.callableAddress(ACell a)	Gets a callable Address from a cell value.
static AccountKey	RT.castAccountKey(ACell a)	Coerce to an AccountKey.
static Address	RT.castAddress(ACell a)	Casts the argument to a valid Address.
static ABlob	RT.castBlob(ACell a)	Converts an object to a canonical blob representation.
static CVMLong	RT.castByte(ACell a)	Explicitly converts a numerical value to a CVM Byte.
static CVMDouble	RT.castDouble(ACell a)	Converts a numerical value to a CVM Double.
static <T extends ACell> AFn<T>	RT.castFunction(ACell a)	Coerces an argument to a function interface.
static AInteger	RT.castInteger(ACell a)	Converts a numerical value to a CVM Integer.
static Keyword	RT.castKeyword(ACell a)	Coerces an named value to a Keyword.
static CVMLong	RT.castLong(ACell a)	Converts a numerical value to a CVM Long.
static <T extends ACell> ASet<T>	RT.castSet(ACell o)	Converts any collection to a set
static <T extends ACell> AVector<T>	RT.castVector(ACell o)	Converts any countable data structure to a vector.
static CVMDouble	RT.ceil(ACell a)	Gets the ceiling of a number after casting to a Double.
static Class<?>	RT.commonNumericType(ACell[] args)	Get the target common numeric type for a given set of arguments.
static Long	RT.compare(ACell a, ACell b, Long nanValue)	Compares two objects representing numbers numerically.
Context	Context.compile(ACell expandedForm)	Compile a form in this Context.
static <T extends ACell> AList<T>	RT.cons(T x, T y, ACell xs)	Prepends two elements to a sequential data structure.
static <T extends ACell> AList<T>	RT.cons(T x, T y, T z, ACell xs)	Prepends three elements to a sequential data structure.
static long	Juice.costNumeric(ACell a)	Gets the base cost for a numeric argument, basically the length in bytes (min 8)
static Long	RT.count(ACell a)	Gets the count of elements in a countable data structure.
static Context.ChainState	Context.ChainState.create(State state, Address origin, Address caller, Address address, long offer, ACell scope)
Context	Context.define(Symbol key, ACell value)	Defines a value in the environment of the current address
Context	Context.defineWithSyntax(Syntax syn, ACell value)	Defines a value in the environment of the current address, updating the metadata
Context	Context.deploy(ACell... code)	Deploys a new account.
static CVMDouble	RT.divide(ACell[] args)
static AccountKey	RT.ensureAccountKey(ACell a)	Implicit cast to an AccountKey.
static Address	RT.ensureAddress(ACell a)	Ensures the argument is a valid Address.
static ADataStructure<?>	RT.ensureAssociative(ACell o)	Ensures the argument is an associative data structure instance.
static ABlob	RT.ensureBlob(ACell a)	Implicitly casts the argument to a Blob
static <V extends ACell> ABlobLike<V>	RT.ensureBlobLike(ACell a)
static CVMChar	RT.ensureChar(ACell a)	Implicitly casts argument to a CVM Character
static <E extends ACell> ACountable<E>	RT.ensureCountable(ACell a)	Casts to an ACountable instance
static <E extends ACell> ADataStructure<E>	RT.ensureDataStructure(ACell a)	Casts to an ADataStructure instance
static CVMDouble	RT.ensureDouble(ACell a)	Ensures the argument is a CVM Double value.
static <T extends ACell> AFn<T>	RT.ensureFunction(ACell a)	Ensure the argument is a valid CVM function.
static Hash	RT.ensureHash(ACell o)	Coerces to Hash type.
static <K extends ACell, V extends ACell> AHashMap<K,V>	RT.ensureHashMap(ACell a)	Casts the argument to a hashmap.
static AInteger	RT.ensureInteger(ACell a)	Ensures the argument is a CVM Integer value.
static CVMLong	RT.ensureLong(ACell a)	Ensures the argument is a CVM Integer within Long range.
static <K extends ACell, V extends ACell> AMap<K,V>	RT.ensureMap(ACell a)	Converts the argument to a non-null Map.
static <K extends ACell, V extends ACell> MapEntry<K,V>	RT.ensureMapEntry(ACell x)	Converts an object to a map entry.
static ANumeric	RT.ensureNumber(ACell a)	Converts a CVM value to the standard numeric representation.
static <T extends ACell> ASequence<T>	RT.ensureSequence(ACell o)	Ensures argument is a sequence data structure.
static <T extends ACell> ASet<T>	RT.ensureSet(ACell a)	Ensures the value is a Set.
static AString	RT.ensureString(ACell a)	Ensures the argument is a CVM String
static Symbol	RT.ensureSymbol(ACell a)	Ensures the argument is a Symbol.
static ATransaction	RT.ensureTransaction(ACell maybeTx)	Casts to a transaction record, or null if not castable
static <T extends ACell> AVector<T>	RT.ensureVector(ACell o)	Ensures argument is a Vector data structure.
static CVMBool	RT.eq(ACell[] values)
boolean	AFn.equals(ACell o)
boolean	AOp.equals(ACell o)
Context	Context.eval(ACell form)	Executes a form in the current context.
Context	Context.evalAs(Address target, ACell form)	Evaluates a form as another Address.
Context	Context.executeLocalBinding(ACell bindingForm, AOp<?> op)	Execute an op, and bind the result to the given binding form in the lexical environment Binding form may be a destructuring form
static CVMDouble	RT.exp(ACell arg)	Computes the result of a exp operation.
Context	Context.expand(ACell form)	Expands a form with the default *initial-expander*
Context	Context.expand(AFn<?> expander, ACell form, AFn<?> cont)
Context	Context.expandCompile(ACell form)	Expand and compile a form in this Context.
static int	RT.findNonNumeric(ACell[] args)	Finds the first non-numeric value in an array.
static CVMDouble	RT.floor(ACell a)	Gets the floor a number after casting to a double.
static CVMBool	RT.ge(ACell[] values)
static ACell	RT.get(ADataStructure<?> coll, ACell key)	Gets an element from a data structure using the given key.
static ACell	RT.get(ADataStructure<?> coll, ACell key, ACell notFound)	Gets an element from a data structure using the given key.
static AType	RT.getType(ACell a)	Get the runtime Type of any CVM value
static CVMBool	RT.gt(ACell[] values)
abstract Context	AFn.invoke(Context context, ACell[] args)
Context	Context.invoke(AFn<?> fn, ACell... args)	Invokes a function within this context, returning an updated context.
Context	IFn.invoke(Context context, ACell[] args)	Invoke this function in the given context.
static boolean	RT.isBoolean(ACell value)	Tests if a value is one of the canonical boolean values 'true' or 'false'
static boolean	RT.isCountable(ACell val)
protected static boolean	Compiler.isListStarting(Symbol element, ACell form)	Returns true if the form is a List starting with value equal to the the specified element
static boolean	RT.isNaN(ACell val)
static boolean	RT.isNumber(ACell val)	Tests if a Value is a valid numerical value type.
static <T> T	RT.json(ACell o)	Converts a CVM value to equivalent JSON value as expressed in equivalent JVM types.
static String	RT.jsonKey(ACell k)	Gets a String from a value suitable for use as a JSON map key
static <T> T	RT.jvm(ACell o)	Converts a CVM value to equivalent JVM value
static <R extends ACell> AVector<R>	RT.keys(ACell a)	Returns a Vector of keys of a Map, or null if the object is not a Map WARNING: Potentially O(n) in size of Map
static CVMBool	RT.le(ACell[] values)
AFn<ACell>	Context.lookupExpander(ACell form)	Looks up an expander from a form in this context
static CVMBool	RT.lt(ACell[] values)
static ACell	RT.max(ACell[] values)	Gets the minimum of a set of numeric values
static ACell	RT.max(ACell a, ACell b)	Gets the minimum of two numeric values
static ACell	RT.min(ACell[] values)	Gets the minimum of a set of numeric values
static ACell	RT.min(ACell a, ACell b)	Gets the minimum of two numeric values
static ANumeric	RT.minus(ACell[] args)
static ANumeric	RT.multiply(ACell... args)
static AString	RT.name(ACell a)	Gets the name from a CVM value.
static <T extends ACell> T	RT.nth(ACell o, long i)	Gets the nth element from a sequential collection.
static Class<?>	RT.numericType(ACell a)	Gets the numeric class of an object
static ANumeric	RT.plus(ACell[] args)
static CVMDouble	RT.pow(ACell[] args)	Computes the result of a pow operation.
static long	Juice.precostNumericLinear(ACell[] args)	Pre-costs a sequence of numeric arguments for addition / multiplication
static long	Juice.precostNumericMultiply(ACell[] args)	Pre-costs a sequence of numeric arguments for multiplication
static long	Juice.priceMemorySize(ACell a)	Calculate price for memory size, mainly used for transaction overhead cost
static AString	RT.print(ACell a)	Prints a value to a String as long as the result fits within a given print limit.
static AString	RT.print(ACell a, long limit)	Prints a cell to a BlobBuilder, up to a specified limit of bytes WARNING: May return null
static boolean	RT.print(BlobBuilder bb, ACell a, long limit)	Prints a cell to a BlobBuilder, up to a specified limit of bytes
Context	Context.queryAs(Address address, ACell form)	Executes code as if run in the specified account, but always rolling back state changes.
static AList<Symbol>	Code.quote(ACell form)	Create code to quote an arbitrary form
Context	Context.run(ACell code)	Executes a form at the top level.
static <T extends ACell> ASequence<T>	RT.sequence(ACell o)	Converts any collection of cells into a Sequence data structure.
Context	Context.setController(ACell address)	Sets the controller for the current Account
Context	Context.setHolding(Address targetAddress, ACell value)	Sets the holding for a specified target account.
static ACell	RT.signum(ACell a)	Gets the signum of a numeric value
static CVMDouble	RT.sqrt(ACell a)	Gets the exact positive square root of a number after casting to a Double.
static AString	RT.str(ACell a)	Converts a value to a CVM String representation.
static AString	RT.str(ACell[] args)	Converts arguments to an AString representation.
boolean	AFn.supportsArgs(ACell[] args)	Tests if this function supports the given argument list By default, checks if the function supports the given arity only.
static String	RT.toString(ACell a)	Converts a value to a Java String representation
static String	RT.toString(ACell a, long limit)	Converts a value to a Java String representation
Context	Context.updateBindings(ACell bindingForm, Object args)	Updates local bindings with a given binding form
static void	RT.validateCell(ACell o)	Validate a Cell.
static <R extends ACell> AVector<R>	RT.values(ACell a)	Returns the vector of values of a map, or null if the object is not a map
Context	Context.withCastError(int argIndex, ACell[] args, AType klass)
Context	Context.withCastError(ACell a, AType klass)
Context	Context.withCastError(ACell a, String message)
Context	Context.withError(Keyword errorCode, ACell rs)
Context	Context.withResult(long gulp, ACell value)
Context	Context.withResult(ACell value)	Returns a context updated with the specified result.
Context.ChainState	Context.ChainState.withScope(ACell newScope)

Method parameters in convex.core.lang with type arguments of type ACell

Modifier and Type	Method	Description
Context	Context.appendLog(AVector<ACell> values)	Appends a log entry for the current address.
Context	Context.compileAll(ASequence<ACell> forms)	Compiles a sequence of forms in the current context.
static long	Juice.costBuildStructure(ACountable<ACell> counted, long n)	Computes the data build cost of a countable structure of given length
Context	Context.setPeerData(AccountKey peerKey, AHashMap<ACell,ACell> data)	Sets peer data.
Context	Context.setPeerData(AccountKey peerKey, AHashMap<ACell,ACell> data)	Sets peer data.
Context.ChainState	Context.ChainState.withEnvironment(AHashMap<Symbol,ACell> newEnvironment, AHashMap<Symbol,AHashMap<ACell,ACell>> newMeta)
Context	Context.withLocalBindings(AVector<ACell> newBindings)	Updates this Context with new local bindings.

Constructors in convex.core.lang with parameters of type ACell

Modifier	Constructor	Description
protected	Context(Context.ChainState chainState, long juice, long juiceLimit, AVector<ACell> localBindings2, ACell result, int depth, AExceptional exception, AVector<AVector<ACell>> log, Context.CompilerState comp)

Constructor parameters in convex.core.lang with type arguments of type ACell

Modifier	Constructor	Description
protected	Context(Context.ChainState chainState, long juice, long juiceLimit, AVector<ACell> localBindings2, ACell result, int depth, AExceptional exception, AVector<AVector<ACell>> log, Context.CompilerState comp)

Uses of ACell in convex.core.lang.impl

Classes in convex.core.lang.impl with type parameters of type ACell

Modifier and Type	Class	Description
class	AClosure<T extends ACell>	Abstract base class for functions that can close over a lexical environment.
class	ADataFn<T extends ACell>	Abstract base class for data structure lookup functions.
class	CoreFn<T extends ACell>	Abstract base class for core language functions implemented in the Runtime Core functions are tagged using their symbols in on-chain representation
class	Fn<T extends ACell>	Value class representing a instantiated closure / lambda function.
class	HaltValue<T extends ACell>	Class representing a halt return value "Computers are useless.
class	KeywordFn<T extends ACell>
class	MapFn<K extends ACell,T extends ACell>
class	MapFn<K extends ACell,T extends ACell>
class	MultiFn<T extends ACell>
class	ReturnValue<T extends ACell>	Class representing a function return value "Computers are useless.
class	RollbackValue<T extends ACell>	Class representing a function return value "Computers are useless.
class	SeqFn<T extends ACell>	Wrapper for interpreting a sequence object as an invokable function
class	SetFn<T extends ACell>

Subclasses of ACell in convex.core.lang.impl

Modifier and Type	Class	Description
class	AClosure<T extends ACell>	Abstract base class for functions that can close over a lexical environment.
class	ADataFn<T extends ACell>	Abstract base class for data structure lookup functions.
class	CoreFn<T extends ACell>	Abstract base class for core language functions implemented in the Runtime Core functions are tagged using their symbols in on-chain representation
class	CorePred	Abstract base class for core predicate functions
class	Fn<T extends ACell>	Value class representing a instantiated closure / lambda function.
class	KeywordFn<T extends ACell>
class	MapFn<K extends ACell,T extends ACell>
class	MultiFn<T extends ACell>
class	SeqFn<T extends ACell>	Wrapper for interpreting a sequence object as an invokable function
class	SetFn<T extends ACell>

Fields in convex.core.lang.impl declared as ACell

Modifier and Type	Field	Description
protected final ACell[]	ATrampoline.args

Fields in convex.core.lang.impl with type parameters of type ACell

Modifier and Type	Field	Description
protected final AVector<ACell>	AClosure.lexicalEnv	Lexical environment saved for this closure

Methods in convex.core.lang.impl with type parameters of type ACell

Modifier and Type	Method	Description
static <T extends ACell, I> Fn<T>	Fn.create(AVector<ACell> params, AOp<T> body)
static <R extends ACell> MultiFn<R>	MultiFn.create(AVector<AClosure<R>> fns)
<R extends ACell> Ref<R>	CoreFn.getRef(int i)
<R extends ACell> Ref<R>	Fn.getRef(int i)
<R extends ACell> Ref<R>	MultiFn.getRef(int i)
static <T extends ACell> Fn<T>	Fn.read(Blob b, int pos)	Decodes a function instance from a Blob encoding.
static <T extends ACell> MultiFn<T>	MultiFn.read(Blob b, int pos)	Decodes a MultiFn instance from a Blob encoding
static <T extends ACell> HaltValue<T>	HaltValue.wrap(T value)
static <T extends ACell> KeywordFn<T>	KeywordFn.wrap(Keyword k)
static <K extends ACell, T extends ACell> MapFn<K,T>	MapFn.wrap(AMap<K,T> m)
static <K extends ACell, T extends ACell> MapFn<K,T>	MapFn.wrap(AMap<K,T> m)
static <T extends ACell> ReturnValue<T>	ReturnValue.wrap(T value)
static <T extends ACell> RollbackValue<T>	RollbackValue.wrap(T value)
static <T extends ACell> SeqFn<T>	SeqFn.wrap(ASequence<?> m)
static <T extends ACell> SetFn<T>	SetFn.wrap(ASet<T> m)

Methods in convex.core.lang.impl that return ACell

Modifier and Type	Method	Description
abstract ACell	AExceptional.getCode()	Returns the Exception code for this exceptional value
ACell	ErrorValue.getCode()	Gets the Error Code for this ErrorValue instance.
ACell	HaltValue.getCode()
ACell	RecurValue.getCode()
ACell	Reduced.getCode()
ACell	ReturnValue.getCode()
ACell	RollbackValue.getCode()
ACell	TailcallValue.getCode()
ACell	ErrorValue.getLog()	Gets the CVM local log at the time of the Error.
abstract ACell	AExceptional.getMessage()	Gets the message for an exceptional value.
ACell	ErrorValue.getMessage()	Gets the optional message associated with this error value, or null if not supplied.
ACell	HaltValue.getMessage()
ACell	RecurValue.getMessage()
ACell	Reduced.getMessage()
ACell	ReturnValue.getMessage()
ACell	RollbackValue.getMessage()
ACell	TailcallValue.getMessage()
ACell	ATrampoline.getValue(int i)
ACell	Reduced.getValue()
ACell[]	ATrampoline.getValues()
ACell	ADataFn.toCanonical()
ACell	Fn.toCanonical()

Methods in convex.core.lang.impl that return types with arguments of type ACell

Modifier and Type	Method	Description
AVector<ACell>	Fn.getParams()	Returns the declared param names for a function.

Methods in convex.core.lang.impl with parameters of type ACell

Modifier and Type	Method	Description
void	ErrorValue.addLog(ACell log)	Stores the CVM local log at the point of the error
static ErrorValue	ErrorValue.create(ACell code)
static ErrorValue	ErrorValue.create(ACell code, AString message)	Creates an ErrorValue with the specified type and message.
static ErrorValue	ErrorValue.create(ACell code, String message)	Creates an ErrorValue with the specified type and message.
static ErrorValue	ErrorValue.createRaw(ACell code, ACell message)	Creates an ErrorValue with the specified type and message.
boolean	CoreFn.equals(ACell o)
Context	ADataFn.invoke(Context context, ACell[] args)
abstract Context	CoreFn.invoke(Context context, ACell[] args)
Context	CorePred.invoke(Context context, ACell[] args)
Context	Fn.invoke(Context context, ACell[] args)
Context	KeywordFn.invoke(Context context, ACell[] args)
Context	MapFn.invoke(Context context, ACell[] args)
Context	MultiFn.invoke(Context context, ACell[] args)
Context	SeqFn.invoke(Context context, ACell[] args)
Context	SetFn.invoke(Context context, ACell[] args)
abstract boolean	CorePred.test(ACell val)
static RecurValue	RecurValue.wrap(ACell... values)	Wraps an object array as a RecurValue
static Reduced	Reduced.wrap(ACell value)
static TailcallValue	TailcallValue.wrap(AFn<?> f, ACell[] args)

Method parameters in convex.core.lang.impl with type arguments of type ACell

Modifier and Type	Method	Description
static <T extends ACell, I> Fn<T>	Fn.create(AVector<ACell> params, AOp<T> body)
abstract <F extends AClosure<T>> F	AClosure.withEnvironment(AVector<ACell> env)	Produces an copy of this closure with the specified environment
<F extends AClosure<T>> F	Fn.withEnvironment(AVector<ACell> env)
<F extends AClosure<T>> F	MultiFn.withEnvironment(AVector<ACell> env)

Constructors in convex.core.lang.impl with parameters of type ACell

Modifier	Constructor	Description
	ATrampoline(ACell[] values)
	Reduced(ACell value)

Constructor parameters in convex.core.lang.impl with type arguments of type ACell

Modifier	Constructor	Description
protected	AClosure(AVector<ACell> lexicalEnv)

Uses of ACell in convex.core.lang.ops

Classes in convex.core.lang.ops with type parameters of type ACell

Modifier and Type	Class	Description
class	AMultiOp<T extends ACell>	Abstract base class for Ops with multiple nested operations MultiOps may selectively evaluate sub-expressions.
class	Cond<T extends ACell>	Op representing a conditional expression.
class	Constant<T extends ACell>	Operation representing a constant value "One man's constant is another man's variable." - Alan Perlis
class	Def<T extends ACell>	Op that creates a definition in the current environment.
class	Do<T extends ACell>	Op for executing a sequence of child operations in order "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
class	Invoke<T extends ACell>	Op representing the invocation of a function.
class	Lambda<T extends ACell>	Op responsible for creating a new function (closure).
class	Let<T extends ACell>	Op for executing a body after lexically binding one or more symbols.
class	Local<T extends ACell>	Op to look up a local value from the lexical environment
class	Lookup<T extends ACell>	Op to look up a Symbol in the current execution context.
class	Query<T extends ACell>	Op for executing a sequence of child operations in order in query mode (no state changes) "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
class	Set<T extends ACell>	Op to set a lexical value in the local execution context.
class	Special<T extends ACell>	Op representing special Symbols like *address* and *caller*

Subclasses of ACell in convex.core.lang.ops

Modifier and Type	Class	Description
class	AMultiOp<T extends ACell>	Abstract base class for Ops with multiple nested operations MultiOps may selectively evaluate sub-expressions.
class	Cond<T extends ACell>	Op representing a conditional expression.
class	Constant<T extends ACell>	Operation representing a constant value "One man's constant is another man's variable." - Alan Perlis
class	Def<T extends ACell>	Op that creates a definition in the current environment.
class	Do<T extends ACell>	Op for executing a sequence of child operations in order "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
class	Invoke<T extends ACell>	Op representing the invocation of a function.
class	Lambda<T extends ACell>	Op responsible for creating a new function (closure).
class	Let<T extends ACell>	Op for executing a body after lexically binding one or more symbols.
class	Local<T extends ACell>	Op to look up a local value from the lexical environment
class	Lookup<T extends ACell>	Op to look up a Symbol in the current execution context.
class	Query<T extends ACell>	Op for executing a sequence of child operations in order in query mode (no state changes) "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
class	Set<T extends ACell>	Op to set a lexical value in the local execution context.
class	Special<T extends ACell>	Op representing special Symbols like *address* and *caller*

Fields in convex.core.lang.ops with type parameters of type ACell

Modifier and Type	Field	Description
protected final AVector<AOp<ACell>>	AMultiOp.ops
protected final AVector<ACell>	Let.symbols	Vector of binding forms.

Methods in convex.core.lang.ops with type parameters of type ACell

Modifier and Type	Method	Description
static <T extends ACell> Invoke<T>	Invoke.build(Object... vals)
static <T extends ACell> Cond<T>	Cond.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Cond<T>	Cond.create(AOp<?>... ops)	Create a Cond operation with the given nested operations
static <T extends ACell> Constant<T>	Constant.create(T value)
static <T extends ACell> Def<T>	Def.create(ACell key)
static <T extends ACell> Def<T>	Def.create(ACell key, Ref<AOp<T>> op)
static <T extends ACell> Def<T>	Def.create(ACell key, AOp<T> op)
static <T extends ACell> Def<T>	Def.create(Symbol key, AOp<T> op)
static <T extends ACell> Def<T>	Def.create(Syntax key, Ref<AOp<T>> op)
static <T extends ACell> Def<T>	Def.create(Syntax key, AOp<T> op)
static <T extends ACell> Def<T>	Def.create(String key, AOp<T> op)
static <T extends ACell> Do<T>	Do.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Do<T>	Do.create(AOp<?>... ops)
static <T extends ACell> Invoke<T>	Invoke.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Invoke<T>	Invoke.create(AOp<?>... ops)
static <T extends ACell, A extends AOp<ACell>, F extends AOp<ACell>> Invoke<T>	Invoke.create(F f, ASequence<A> args)
static <T extends ACell, A extends AOp<ACell>, F extends AOp<ACell>> Invoke<T>	Invoke.create(F f, ASequence<A> args)
static <T extends ACell, A extends AOp<ACell>, F extends AOp<ACell>> Invoke<T>	Invoke.create(F f, ASequence<A> args)
static <T extends ACell> Invoke<T>	Invoke.create(String string, AOp<?>... args)
static <T extends ACell> Lambda<T>	Lambda.create(AVector<ACell> params, AOp<T> body)
static <T extends ACell> Lambda<T>	Lambda.create(AClosure<T> fn)
static <T extends ACell> Let<T>	Let.create(AVector<ACell> syms, AVector<AOp<ACell>> ops, boolean isLoop)
static final <R extends ACell> Local<R>	Local.create(long position)	Creates Local to look up a lexical value in the given position
static <T extends ACell> Lookup<T>	Lookup.create(Address addr, Symbol sym)
static <T extends ACell> Lookup<T>	Lookup.create(Symbol symbol)
static <T extends ACell> Lookup<T>	Lookup.create(AOp<Address> address, Symbol form)
static <T extends ACell> Lookup<T>	Lookup.create(AOp<Address> address, String name)
static <T extends ACell> Lookup<T>	Lookup.create(String name)
static <T extends ACell> Query<T>	Query.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Query<T>	Query.create(AOp<?>... ops)
static final <R extends ACell> Set<R>	Set.create(long position, AOp<R> op)	Creates Set Op for the given opCode
static <T extends ACell> Constant<T>	Constant.createFromRef(Ref<T> valueRef)
static <R extends ACell> Special<R>	Special.forSymbol(Symbol sym)	Gets the special Op for a given Symbol, or null if not found
static <R extends ACell> Special<R>	Special.get(String string)
<R extends ACell> Ref<R>	AMultiOp.getRef(int i)
<R extends ACell> Ref<R>	Constant.getRef(int i)
<R extends ACell> Ref<R>	Lambda.getRef(int i)
final <R extends ACell> Ref<R>	Let.getRef(int i)
<R extends ACell> Ref<R>	Lookup.getRef(int i)
static <T extends ACell> AOp<T>	Constant.nil()
static <T extends ACell> Constant<T>	Constant.of(Object value)
static <T extends ACell> Constant<T>	Constant.of(T value)
static <T extends ACell> Cond<T>	Cond.read(Blob b, int pos)	Decodes a Cond op from a Blob encoding.
static <T extends ACell> Constant<T>	Constant.read(Blob b, int pos)
static <T extends ACell> Def<T>	Def.read(Blob b, int pos)	Decodes a Def op from a Blob encoding
static <T extends ACell> Do<T>	Do.read(Blob b, int pos)	Decodes a Do op from a Blob encoding
static <T extends ACell> Invoke<T>	Invoke.read(Blob b, int pos)	Read an Invoke Op from a Blob encoding
static <T extends ACell> Lambda<T>	Lambda.read(Blob b, int pos)
static <T extends ACell> Let<T>	Let.read(Blob b, int pos, boolean isLoop)	Read a Let Op from a Blob encoding
static <R extends ACell> Local<R>	Local.read(Blob b, int pos)
static <T extends ACell> Lookup<T>	Lookup.read(Blob b, int pos)	Reads a Lookup op from a Blob encoding
static <T extends ACell> Query<T>	Query.read(Blob b, int pos)	Read a Query Op from a Blob encoding
static <R extends ACell> Set<R>	Set.read(Blob b, int pos)	Reads a Set Op from a Blob encoding
static <T extends ACell> AOp<T>	Special.read(Blob b, int pos)

Methods in convex.core.lang.ops with parameters of type ACell

Modifier and Type	Method	Description
static <T extends ACell> Def<T>	Def.create(ACell key)
static <T extends ACell> Def<T>	Def.create(ACell key, Ref<AOp<T>> op)
static <T extends ACell> Def<T>	Def.create(ACell key, AOp<T> op)

Method parameters in convex.core.lang.ops with type arguments of type ACell

Modifier and Type	Method	Description
static <T extends ACell> Cond<T>	Cond.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Do<T>	Do.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Invoke<T>	Invoke.create(ASequence<AOp<ACell>> ops)
static <T extends ACell> Lambda<T>	Lambda.create(AVector<ACell> params, AOp<T> body)
static <T extends ACell> Let<T>	Let.create(AVector<ACell> syms, AVector<AOp<ACell>> ops, boolean isLoop)
static <T extends ACell> Query<T>	Query.create(ASequence<AOp<ACell>> ops)
protected abstract AMultiOp<T>	AMultiOp.recreate(ASequence<AOp<ACell>> newOps)	Recreates this object with an updated list of child Ops.
protected Cond<T>	Cond.recreate(ASequence<AOp<ACell>> newOps)
protected Do<T>	Do.recreate(ASequence<AOp<ACell>> newOps)
protected Invoke<T>	Invoke.recreate(ASequence<AOp<ACell>> newOps)
protected Let<T>	Let.recreate(ASequence<AOp<ACell>> newOps)
protected Let<T>	Let.recreate(ASequence<AOp<ACell>> newOps, AVector<ACell> newSymbols)
protected Let<T>	Let.recreate(ASequence<AOp<ACell>> newOps, AVector<ACell> newSymbols)
protected Query<T>	Query.recreate(ASequence<AOp<ACell>> newOps)

Constructor parameters in convex.core.lang.ops with type arguments of type ACell

Modifier	Constructor	Description
protected	AMultiOp(AVector<AOp<ACell>> ops)
protected	Cond(AVector<AOp<ACell>> ops)
protected	Do(AVector<AOp<ACell>> ops)
protected	Invoke(AVector<AOp<ACell>> ops)
protected	Let(AVector<ACell> syms, AVector<AOp<ACell>> ops, boolean isLoop)
protected	Query(AVector<AOp<ACell>> ops)

Uses of ACell in convex.core.lang.reader

Methods in convex.core.lang.reader with type parameters of type ACell

Modifier and Type	Method	Description
<R extends ACell> R	AntlrReader.CRListener.pop()

Methods in convex.core.lang.reader that return ACell

Modifier and Type	Method	Description
static ACell	AntlrReader.read(Reader r)
static ACell	AntlrReader.read(String s)
static ACell	AntlrReader.read(org.antlr.v4.runtime.CharStream cs)
static ACell	ReaderUtils.specialLiteral(String s)

Methods in convex.core.lang.reader that return types with arguments of type ACell

Modifier and Type	Method	Description
static AHashMap<ACell,ACell>	ReaderUtils.interpretMetadata(ACell metaNode)	Converts a metadata object according to the following rule: - Map -> unchanged - Keyword -> {:keyword true} - Any other expression -> {:tag expression}
static AHashMap<ACell,ACell>	ReaderUtils.interpretMetadata(ACell metaNode)	Converts a metadata object according to the following rule: - Map -> unchanged - Keyword -> {:keyword true} - Any other expression -> {:tag expression}
ArrayList<ACell>	AntlrReader.CRListener.popList()
static AList<ACell>	AntlrReader.readAll(String source)
static AList<ACell>	AntlrReader.readAll(org.antlr.v4.runtime.CharStream cs)

Methods in convex.core.lang.reader with parameters of type ACell

Modifier and Type	Method	Description
static AHashMap<ACell,ACell>	ReaderUtils.interpretMetadata(ACell metaNode)	Converts a metadata object according to the following rule: - Map -> unchanged - Keyword -> {:keyword true} - Any other expression -> {:tag expression}
void	AntlrReader.CRListener.push(ACell a)

Uses of ACell in convex.core.store

Methods in convex.core.store with type parameters of type ACell

Modifier and Type	Method	Description
<T extends ACell> Ref<T>	ACachedStore.checkCache(Hash h)
abstract <T extends ACell> Ref<T>	AStore.checkCache(Hash h)	checks in-memory cache for a stored Ref.
<T extends ACell> Ref<T>	MemoryStore.checkCache(Hash h)
final <T extends ACell> T	ACachedStore.decode(Blob encoding)
abstract <T extends ACell> T	AStore.decode(Blob encoding)	Decodes a Cell from an Encoding.
final <T extends ACell> T	MemoryStore.decode(Blob encoding)
<T extends ACell> T	AStore.getRootData()	Gets the Root Data from the Store.
<T extends ACell> T	MemoryStore.getRootData()
<T extends ACell> Ref<T>	AStore.getRootRef()	Gets a Ref for Root Data.
<T extends ACell> Ref<T>	MemoryStore.persistRef(Ref<T> ref, Consumer<Ref<ACell>> noveltyHandler, int requiredStatus, boolean topLevel)
abstract <T extends ACell> Ref<T>	AStore.refForHash(Hash hash)	Gets the stored Ref for a given hash value, or null if not found in the store.
<T extends ACell> Ref<T>	MemoryStore.refForHash(Hash hash)
abstract <T extends ACell> Ref<T>	AStore.setRootData(T data)	Sets the root data for this Store
<T extends ACell> Ref<T>	MemoryStore.setRootData(T data)
abstract <T extends ACell> Ref<T>	AStore.storeRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)	Stores a @Ref in long term storage as defined by this store implementation.
<T extends ACell> Ref<T>	MemoryStore.storeRef(Ref<T> r2, int status, Consumer<Ref<ACell>> noveltyHandler)
abstract <T extends ACell> Ref<T>	AStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)	Stores a top level @Ref in long term storage as defined by this store implementation.
<T extends ACell> Ref<T>	MemoryStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)

Methods in convex.core.store that return ACell

Modifier and Type	Method	Description
protected ACell	AStore.decodeImpl(Blob encoding)

Methods in convex.core.store with parameters of type ACell

Modifier and Type	Method	Description
void	RefCache.putCell(ACell cell)	Stores a Ref in the cache

Method parameters in convex.core.store with type arguments of type ACell

Modifier and Type	Method	Description
<T extends ACell> Ref<T>	MemoryStore.persistRef(Ref<T> ref, Consumer<Ref<ACell>> noveltyHandler, int requiredStatus, boolean topLevel)
abstract <T extends ACell> Ref<T>	AStore.storeRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)	Stores a @Ref in long term storage as defined by this store implementation.
<T extends ACell> Ref<T>	MemoryStore.storeRef(Ref<T> r2, int status, Consumer<Ref<ACell>> noveltyHandler)
abstract <T extends ACell> Ref<T>	AStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)	Stores a top level @Ref in long term storage as defined by this store implementation.
<T extends ACell> Ref<T>	MemoryStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)

Uses of ACell in convex.core.transactions

Subclasses of ACell in convex.core.transactions

Modifier and Type	Class	Description
class	ATransaction	Abstract base class for immutable transactions Transactions may modify the on-chain State according to the rules of the specific transaction type.
class	Call	Transaction representing a Call to an Actor.
class	Invoke	Transaction class representing the Invoke of an on-chain operation.
class	Multi	The Multi class enables multiple child transactions to be grouped into a single wrapper transaction with useful joint execution semantics.
class	Transfer	Transaction class representing a coin Transfer from one account to another

Fields in convex.core.transactions declared as ACell

Modifier and Type	Field	Description
protected final ACell	Invoke.command

Fields in convex.core.transactions with type parameters of type ACell

Modifier and Type	Field	Description
protected final AVector<ACell>	Call.args

Methods in convex.core.transactions with type parameters of type ACell

Modifier and Type	Method	Description
<T extends ACell> Ref<T>	Call.getRef(int i)
<R extends ACell> Ref<R>	Invoke.getRef(int i)
<R extends ACell> Ref<R>	Multi.getRef(int i)
<R extends ACell> Ref<R>	Transfer.getRef(int i)

Methods in convex.core.transactions that return ACell

Modifier and Type	Method	Description
ACell	Call.get(Keyword key)
ACell	Invoke.get(Keyword key)
ACell	Multi.get(Keyword key)
ACell	Transfer.get(Keyword key)
ACell	Transfer.updateRefs(IRefFunction func)

Methods in convex.core.transactions with parameters of type ACell

Modifier and Type	Method	Description
static Invoke	Invoke.create(Address address, long sequence, ACell command)
boolean	ATransaction.equals(ACell o)

Method parameters in convex.core.transactions with type arguments of type ACell

Modifier and Type	Method	Description
static Call	Call.create(Address address, long sequence, Address target, long offer, Symbol functionName, AVector<ACell> args)
static Call	Call.create(Address address, long sequence, Address target, Symbol functionName, AVector<ACell> args)

Constructors in convex.core.transactions with parameters of type ACell

Modifier	Constructor	Description
protected	Invoke(Address address, long sequence, ACell args)

Constructor parameters in convex.core.transactions with type arguments of type ACell

Modifier	Constructor	Description
protected	Call(Address address, long sequence, Address target, long offer, Symbol functionName, AVector<ACell> args)

Uses of ACell in convex.core.util

Methods in convex.core.util with type parameters of type ACell

Modifier and Type	Method	Description
static <T extends ACell, U> long	Utils.binarySearch(ASequence<T> data, Function<? super T,U> value, Comparator<U> comparator, U target)	Binary Search for an exact or approximate (leftmost) value.
static <T extends ACell, U> T	Utils.binarySearchLeftmost(ASequence<T> L, Function<? super T,U> value, Comparator<U> comparator, U target)	Leftmost Binary Search.

Methods in convex.core.util with parameters of type ACell

Modifier and Type	Method	Description
static boolean	Utils.equals(ACell a, ACell b)	Equality method allowing for nulls

Uses of ACell in convex.dlfs

Methods in convex.dlfs that return types with arguments of type ACell

Modifier and Type	Method	Description
static AVector<ACell>	DLFSNode.createDirectory(CVMLong timestamp)
static AVector<ACell>	DLFSNode.createEmptyFile(CVMLong timestamp)
abstract AVector<ACell>	DLFileSystem.createFile(DLPath path)	Creates a file, returning the new node
static AVector<ACell>	DLFSNode.createTombstone(CVMLong timestamp)
static AHashMap<AString,AVector<ACell>>	DLFSNode.getDirectoryEntries(AVector<ACell> dirNode)	Gets the directory entries for a node
static MapEntry<AString,AVector<ACell>>	DLFSNode.getDirectoryEntry(AVector<ACell> node, AString name)
abstract AVector<ACell>	DLFileSystem.getNode(DLPath path)	Gets DLFS node for the given path
static AVector<ACell>	DLFSNode.merge(AVector<ACell> a, AVector<ACell> b, CVMLong time)	Merges two DLFS nodes recursively.
static AVector<ACell>	DLFSNode.navigate(AVector<ACell> node, DLPath path)	Navigate down a path relative to a DLFS Node.
abstract AVector<ACell>	DLFileSystem.updateNode(DLPath path, AVector<ACell> newNode)	Updates a node, returning the new node
static AVector<ACell>	DLFSNode.updateNode(AVector<ACell> rootNode, DLPath path, AVector<ACell> newNode, CVMLong utime)	Update a node at a path relative to a root node

Method parameters in convex.dlfs with type arguments of type ACell

Modifier and Type	Method	Description
static ABlob	DLFSNode.getData(AVector<ACell> node)	Gets the data from a DLFS file node, or nil if not a regular File
static AHashMap<AString,AVector<ACell>>	DLFSNode.getDirectoryEntries(AVector<ACell> dirNode)	Gets the directory entries for a node
static MapEntry<AString,AVector<ACell>>	DLFSNode.getDirectoryEntry(AVector<ACell> node, AString name)
static Blob	DLFSNode.getMetaData(AVector<ACell> node)	Gets the metadata from a DLFS node
static CVMLong	DLFSNode.getUTime(AVector<ACell> node)	Gets the metadata from a DLFS node
static boolean	DLFSNode.isDirectory(AVector<ACell> node)
static boolean	DLFSNode.isRegularFile(AVector<ACell> node)
static boolean	DLFSNode.isTombstone(AVector<ACell> node)	Returns true iff the node is a DLFS tombstone
abstract void	DLFileSystem.merge(AVector<ACell> other)	Merges another DLFS drive into this one
static AVector<ACell>	DLFSNode.merge(AVector<ACell> a, AVector<ACell> b, CVMLong time)	Merges two DLFS nodes recursively.
static AVector<ACell>	DLFSNode.navigate(AVector<ACell> node, DLPath path)	Navigate down a path relative to a DLFS Node.
abstract AVector<ACell>	DLFileSystem.updateNode(DLPath path, AVector<ACell> newNode)	Updates a node, returning the new node
static AVector<ACell>	DLFSNode.updateNode(AVector<ACell> rootNode, DLPath path, AVector<ACell> newNode, CVMLong utime)	Update a node at a path relative to a root node

Uses of ACell in convex.dlfs.impl

Methods in convex.dlfs.impl that return types with arguments of type ACell

Modifier and Type	Method	Description
AVector<ACell>	DLFSLocal.createFile(DLPath path)
AVector<ACell>	DLFSLocal.getNode(DLPath path)
protected AVector<ACell>	DLFileChannel.updateNode(AVector<ACell> newNode)
AVector<ACell>	DLFSLocal.updateNode(DLPath dir, AVector<ACell> newNode)

Method parameters in convex.dlfs.impl with type arguments of type ACell

Modifier and Type	Method	Description
static DLDirectoryStream	DLDirectoryStream.create(DLPath base, AVector<ACell> dirNode)
static DLFSFileAttributes	DLFSFileAttributes.create(AVector<ACell> node)
void	DLFSLocal.merge(AVector<ACell> other)
protected AVector<ACell>	DLFileChannel.updateNode(AVector<ACell> newNode)
AVector<ACell>	DLFSLocal.updateNode(DLPath dir, AVector<ACell> newNode)

Constructor parameters in convex.dlfs.impl with type arguments of type ACell

Modifier	Constructor	Description
	DLDirectoryStream(DLPath base, AHashMap<AString,AVector<ACell>> dirs)
	DLFSFileAttributes(AVector<ACell> node)
	DLFSLocal(DLFSProvider dlfsProvider, String uriPath, AVector<ACell> rootNode)

Uses of ACell in etch

Methods in etch with type parameters of type ACell

Modifier and Type	Method	Description
protected <T extends ACell> void	EtchStore.addToCache(Ref<T> ref)
<T extends ACell> RefSoft<T>	Etch.read(AArrayBlob key)	Reads a Blob from the database, returning null if not found
<T extends ACell> RefSoft<T>	Etch.read(AArrayBlob key, long pointer)
<T extends ACell> T	Etch.readCell(long ptr)	Reads a Cell from the specified location in an Etch file.
<T extends ACell> Ref<T>	EtchStore.readStoreRef(Hash hash)
<T extends ACell> Ref<T>	EtchStore.refForHash(Hash hash)
<T extends ACell> Ref<T>	EtchStore.setRootData(T data)
<T extends ACell> Ref<T>	EtchStore.storeRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)
<T extends ACell> Ref<T>	EtchStore.storeRef(Ref<T> ref, int requiredStatus, Consumer<Ref<ACell>> noveltyHandler, boolean topLevel)
<T extends ACell> Ref<T>	EtchStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)

Methods in etch that return types with arguments of type ACell

Modifier and Type	Method	Description
Ref<ACell>	Etch.write(AArrayBlob key, Ref<ACell> value)	Writes a key / value pair to the immutable store.

Methods in etch with parameters of type ACell

Modifier and Type	Method	Description
protected abstract void	EtchUtils.EtchCellVisitor.visitCell(ACell cell)

Method parameters in etch with type arguments of type ACell

Modifier and Type	Method	Description
<T extends ACell> Ref<T>	EtchStore.storeRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)
<T extends ACell> Ref<T>	EtchStore.storeRef(Ref<T> ref, int requiredStatus, Consumer<Ref<ACell>> noveltyHandler, boolean topLevel)
<T extends ACell> Ref<T>	EtchStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)
Ref<ACell>	Etch.write(AArrayBlob key, Ref<ACell> value)	Writes a key / value pair to the immutable store.