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.data	Data structures and algorithms, including a complete set of classes required to implement immutable, decentralised data objects.
convex.core.data.prim	Implementation of CVM Primitive Data types
convex.core.data.type	CVM type system implementation.
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
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.
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 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
<T extends ACell> Context<T>	State.applyTransaction(ATransaction t)	Applies a transaction to the State.
<T extends ACell> Context<T>	Peer.executeDryRun(ATransaction transaction)	Executes a "dry run" transaction on the current consensus state of this Peer.
<T extends ACell> Context<T>	Peer.executeQuery(ACell form)	Executes a query in this Peer's current Consensus State, using a default address
<T extends ACell> Context<T>	Peer.executeQuery(ACell form, Address address)	Compiles and executes a query on the current consensus state of this Peer.
<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>	State.getRef(int i)
<T extends ACell> T	Result.getValue()	Returns the value for this result.
<T extends ACell> SignedData<T>	MergeContext.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(ACell k)
ACell	Block.get(ACell k)
ACell	BlockResult.get(ACell key)
ACell	Order.get(ACell key)
ACell	State.get(ACell k)
ACell	BlockResult.getErrorCode(long i)	Gets the error code for a given transaction
ACell	Result.getErrorCode()	Returns the Error Code from this Result.
ACell	Result.getID()	Returns the message ID for this result.

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.
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.
BlobMap<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 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, AMap<Keyword,ACell> info)	Create a Result
boolean	Belief.equals(ACell a)
boolean	Block.equals(ACell a)
boolean	BlockResult.equals(ACell a)
boolean	State.equals(ACell a)
<T extends ACell> Context<T>	Peer.executeQuery(ACell form)	Executes a query in this Peer's current Consensus State, using a default address
<T extends ACell> Context<T>	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
ACell	Belief.get(ACell k)
ACell	Block.get(ACell k)
ACell	BlockResult.get(ACell key)
ACell	Order.get(ACell key)
ACell	State.get(ACell k)
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.create(CVMLong id, ACell value, ACell errorCode, AMap<Keyword,ACell> info)	Create a Result
static Peer	Peer.fromData(AKeyPair keyPair, AMap<Keyword,ACell> peerData)	Constructs a Peer instance from persisted PEer Data
protected Result	Result.withValues(AVector<ACell> newValues)

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
<R extends ACell> SignedData<R>	WalletEntry.sign(R message)
abstract <R extends ACell> SignedData<R>	AKeyPair.signData(R value)	Signs a 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.data

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

Modifier and Type	Class	Description
class	ABlobMap<K extends ABlob,V extends ACell>	Abstract base class for BlobMaps: a sorted radix-tree map of Blobs to Values.
class	ACollection<T extends ACell>	Abstract base class for Persistent Merkle Collections
class	ACountable<E extends ACell>	Abstract base class for Countable objects.
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	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	AVector<T extends ACell>	Abstract base class for vectors.
class	BlobMap<K extends ABlob,V extends ACell>	BlobMap node implementation supporting: An optional prefix string An optional entry with this prefix Up to 16 child entries at the next level of depth
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
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>	Experimental: implementation of AVector backed by a Java array for temporary usage purposes.
class	VectorBuilder<T extends ACell>	Similar to Java StringBuilder designed for concatenating multiple small Vectors to produce a larger Vector.
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	ABlobMap<K extends ABlob,V extends ACell>	Abstract base class for BlobMaps: a sorted radix-tree map of Blobs to Values.
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.
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	AHashMap<K extends ACell,V extends ACell>
class	AHashSet<T extends ACell>
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	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	BlobMap<K extends ABlob,V extends ACell>	BlobMap node implementation supporting: An optional prefix string An optional entry with this prefix Up to 16 child entries at the next level of depth
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.
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 BlobMaps.
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.
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 subsequence of some Blob data
class	StringTree	String implementation class wrapping a BlobTree.
class	Symbol	Class representing a Symbol.
class	Syntax	Class representing a Syntax Object.
class	VectorArray<T extends ACell>	Experimental: implementation of AVector backed by a Java array for temporary usage purposes.
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[]	ACell.EMPTY_ARRAY	An empty Java array of cells
protected final ACell[]	VectorBuilder.tail	Accumulator array for up to a single chunk worth 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.
static final BlobMap<ABlob,ACell>	BlobMap.EMPTY	Empty BlobMap singleton
protected AVector<ACell>	ARecordGeneric.values

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

Modifier and Type	Method	Description
<T extends ACell> T	ACell.announce()
<T extends ACell> T	ACell.announce(Consumer<Ref<ACell>> noveltyHandler)
abstract <R extends ACell> AList<R>	AList.assoc(long i, R value)
abstract <R extends ACell> ASequence<R>	ASequence.assoc(long i, R value)	Updates a value at the given position in the sequence.
abstract <R extends ACell> AVector<R>	AVector.assoc(long i, R value)
<R extends ACell> AList<R>	List.assoc(long i, R value)
<R extends ACell> AVector<R>	MapEntry.assoc(long i, R a)
<R extends ACell> AVector<R>	VectorArray.assoc(long i, R value)
<R extends ACell> AVector<R>	VectorLeaf.assoc(long i, R value)
<R extends ACell> AVector<R>	VectorTree.assoc(long i, R value)
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)
abstract <R extends ACell> AList<R>	AList.concat(ASequence<R> vals)
abstract <R extends ACell> ASequence<R>	ASequence.concat(ASequence<R> vals)	Concatenates the elements from another sequence to the end of this sequence.
abstract <R extends ACell> AVector<R>	AVector.concat(ASequence<R> b)
<R extends ACell> List<R>	List.concat(ASequence<R> vals)
<R extends ACell> AVector<R>	MapEntry.concat(ASequence<R> b)
<R extends ACell> AVector<R>	VectorArray.concat(ASequence<R> b)
<R extends ACell> AVector<R>	VectorLeaf.concat(ASequence<R> b)
<R extends ACell> AVector<R>	VectorTree.concat(ASequence<R> b)
abstract <R extends ACell> ACollection<R>	ACollection.conj(R x)	Adds an element to this collection, according to the natural semantics of the collection
abstract <R extends ACell> ADataStructure<R>	ADataStructure.conj(R x)	Adds an element to this data structure, in the natural manner defined by the general data structure type.
<R extends ACell> AHashSet<R>	AHashSet.conj(R a)
abstract <R extends ACell> AList<R>	AList.conj(R x)	Adds an element to this list, in first position.
<R extends ACell> ADataStructure<R>	AMap.conj(R x)	Adds a new map entry to this map.
abstract <R extends ACell> ASequence<R>	ASequence.conj(R value)	Adds an element to the sequence in the natural position
abstract <R extends ACell> ASet<R>	ASet.conj(R a)
final <R extends ACell> AVector<R>	AVector.conj(R value)
<R extends ACell> List<R>	List.conj(R value)	Prepends an element to the list in first position.
<R extends ACell> ADataStructure<R>	ADataStructure.conjAll(ACollection<R> xs)	Adds multiple elements to this data structure, in the natural manner defined by the general data structure type.
<R extends ACell> ASet<R>	AHashSet.conjAll(ACollection<R> elements)
abstract <R extends ACell> ASet<R>	ASet.conjAll(ACollection<R> xs)
<R extends ACell> AVector<R>	AVector.conjAll(ACollection<R> xs)
<R extends ACell> List<R>	List.conjAll(ACollection<R> xs)
static <K extends ABlob, V extends ACell> BlobMap<K,V>	BlobMap.create(MapEntry<K,V> me)
static <K extends ABlob, V extends ACell> BlobMap<K,V>	BlobMap.create(K k, V v)
static <R extends ABlobMap<K, V>, K extends ABlob, V extends ACell> R	BlobMaps.create(HashMap<K,V> map)
static <R extends ABlobMap<K, V>, K extends ABlob, V extends ACell> R	BlobMaps.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(AKeyPair keyPair, T value2)
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> T	ACell.createAnnounced(T value, Consumer<Ref<ACell>> noveltyHandler)	Creates an ANNOUNCED Ref with the given value in the current store.
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.
static <T extends ACell> Ref<T>	ACell.createPersisted(T value)	Creates a persisted Ref with the given value in the current store.
static <T extends ACell> Ref<T>	ACell.createPersisted(T value, Consumer<Ref<ACell>> noveltyHandler)	Creates a persisted Ref with the given value in the current store.
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 <T extends ACell> SignedData<T>	SignedData.createWithRef(AKeyPair keyPair, Ref<T> ref)	Signs a data value Ref with the given keypair.
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 <R extends ABlobMap<K, V>, K extends ABlob, V extends ACell> R	BlobMaps.empty()	Returns the empty BlobMap.
static <T extends ACell> AList<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
<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.
abstract <R extends ACell> Ref<R>	ABlobMap.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.
abstract <R extends ACell> Ref<R>	AMapEntry.getRef(int i)
<R extends ACell> Ref<R>	ARecordGeneric.getRef(int index)
<R extends ACell> Ref<R>	BlobMap.getRef(int i)
<R extends ACell> Ref<R>	BlobTree.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>	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)
<R extends ACell> AHashSet<R>	AHashSet.include(R a)
abstract <R extends ACell> ASet<R>	ASet.include(R a)	Updates the set to include the given element
<R extends ACell> ASet<R>	AHashSet.includeAll(ASet<R> elements)
abstract <R extends ACell> ASet<R>	ASet.includeAll(ASet<R> elements)	Updates the set to include all the given elements.
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)
<T extends ACell> T	ACell.mark()
<T extends ACell> T	ACell.mark(Consumer<Ref<ACell>> noveltyHandler)
static <K extends ABlob, V extends ACell> BlobMap<K,V>	BlobMap.of(Object k, Object v)
static <R extends ABlobMap<K, V>, K extends ABlob, V extends ACell> R	BlobMaps.of(Object... kvs)
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> AVector<T>	Vectors.of(Object... elements)	Creates a vector with the given values.
<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 <K extends ABlob, V extends ACell> BlobMap<K,V>	BlobMap.read(Blob b, int pos)
static <K extends ABlob, V extends ACell> BlobMap<K,V>	BlobMap.read(ByteBuffer bb)
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 <T extends ACell> T	Format.read(ByteBuffer bb)	Reads one complete Cell from a ByteBuffer.
static <T extends ACell> List<T>	List.read(Blob b, int pos)	Reads a List from the specified Blob.
static <T extends ACell> List<T>	List.read(ByteBuffer bb)	Reads a List from the specified bytebuffer.
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.read(Blob b, int pos, long count)
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.read(Blob b, int pos, long count)
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.read(ByteBuffer bb, long count)	Reads a MapLeaf from the provided ByteBuffer Assumes the header byte is already read.
static <K extends ACell, V extends ACell> MapLeaf<K,V>	MapLeaf.read(ByteBuffer bb, long count)	Reads a MapLeaf from the provided ByteBuffer Assumes the header byte is already read.
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> AHashMap<K,V>	Maps.read(ByteBuffer bb)	Read a Hashmap from a ByteBuffer.
static <K extends ACell, V extends ACell> AHashMap<K,V>	Maps.read(ByteBuffer bb)	Read a Hashmap from a ByteBuffer.
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.read(Blob b, int pos, long count)
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.read(Blob b, int pos, long count)
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.read(ByteBuffer bb, long count)	Reads a ListMap from the provided ByteBuffer Assumes the header byte and count is already read.
static <K extends ACell, V extends ACell> MapTree<K,V>	MapTree.read(ByteBuffer bb, long count)	Reads a ListMap from the provided ByteBuffer Assumes the header byte and count is already read.
static <V extends ACell> SetLeaf<V>	SetLeaf.read(Blob b, int pos, long count)
static <V extends ACell> SetLeaf<V>	SetLeaf.read(ByteBuffer bb, 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 <T extends ACell> ASet<T>	Sets.read(ByteBuffer bb)
static <V extends ACell> SetTree<V>	SetTree.read(Blob b, int pos, long count)
static <V extends ACell> SetTree<V>	SetTree.read(ByteBuffer bb, long count)	Reads a SetTree from the provided ByteBuffer Assumes the header byte and count is already read.
static <T extends ACell> SignedData<T>	SignedData.read(Blob b, int pos)
static <T extends ACell> SignedData<T>	SignedData.read(ByteBuffer data)	Reads a SignedData instance from the given ByteBuffer
static <T extends ACell> VectorLeaf<T>	VectorLeaf.read(long count, Blob b, int pos)
static <T extends ACell> VectorLeaf<T>	VectorLeaf.read(ByteBuffer bb, long count)	Reads a VectorLeaf from the provided ByteBuffer Assumes the header byte and count is already read.
static <T extends ACell> AVector<T>	Vectors.read(Blob b, int pos)
static <T extends ACell> AVector<T>	Vectors.read(ByteBuffer bb)	Reads a Vector for the specified bytebuffer.
static <T extends ACell> VectorTree<T>	VectorTree.read(long count, Blob b, int pos)
static <T extends ACell> VectorTree<T>	VectorTree.read(ByteBuffer bb, long count)	Reads a VectorTree from the provided ByteBuffer Assumes the header byte and count is already read.
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>	Ref.readRaw(ByteBuffer data)	Reads a ref from the given ByteBuffer.
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> Ref<T>	Format.readRef(ByteBuffer bb)	Reads a Ref or embedded Cell value from the ByteBuffer.
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
abstract <R extends ACell> AVector<R>	ASequence.subVector(long start, long length)	Gets a vector containing the specified subset of this sequence.
<R extends ACell> AVector<R>	MapEntry.subVector(long start, long length)
<R extends ACell> VectorArray<R>	VectorArray.subVector(long start, long length)
<R extends ACell> AVector<R>	VectorLeaf.subVector(long start, long length)
abstract <R extends ACell> AVector<R>	ACollection.toVector()	Converts this collection to a canonical vector of elements
<R extends ACell> AVector<R>	ASet.toVector()
<R extends ACell> AVector<R>	MapEntry.toVector()
final <R extends ACell> AVector<R>	VectorLeaf.toVector()
final <R extends ACell> AVector<R>	VectorTree.toVector()
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> 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)

Methods in convex.core.data that return ACell

Modifier and Type	Method	Description
static ACell[]	Format.decodeCells(Blob data)
ACell	AccountStatus.get(ACell 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)
abstract ACell	ARecord.get(ACell key)	Gets the record field content for a given key, or null if not found.
final ACell	ARecord.get(Object key)	Gets the record field content for a given key, or null if not found.
ACell	ARecordGeneric.get(ACell key)
ACell	ASequence.get(ACell key, ACell notFound)
ACell	ASet.get(ACell key, ACell notFound)
ACell	MapEntry.get(long i)
ACell	PeerStatus.get(ACell key)
ACell	SignedData.get(ACell key)
final ACell	ACell.getCanonical()	Gets the canonical representation of this Cell.
ACell	AccountStatus.getHolding(Address addr)
ACell[]	ARecord.getValuesArray()	Gets an array containing all values in this record, in format-defined key order.
final ACell	AMapEntry.set(int index, ACell element)
abstract ACell	ACell.toCanonical()	Converts this Cell to its canonical version.
ACell	BlobMap.toCanonical()
ACell	Keyword.toCanonical()
ACell	List.toCanonical()
ACell	MapEntry.toCanonical()
ACell	MapLeaf.toCanonical()
ACell	StringShort.toCanonical()
ACell	Symbol.toCanonical()
ACell	Syntax.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
ACell	ACell.updateRefs(IRefFunction func)	Updates all Refs in this object using the given function.

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(VectorLeaf<ACell> listVector)
AMap<Keyword,ACell>	ARecord.assoc(ACell key, ACell value)
AMap<Keyword,ACell>	ARecord.assocEntry(MapEntry<Keyword,ACell> e)
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)
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.
ABlobMap<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()
AHashMap<Symbol,AHashMap<ACell,ACell>>	AccountStatus.getMetadata()
AHashMap<ACell,ACell>	PeerStatus.getMetadata()	Gets the Metadata of this Peer
AHashMap<ACell,ACell>	PeerStatus.getMetadata()	Gets the Metadata of this Peer
Iterator<ACell>	AMapEntry.iterator()
ListIterator<ACell>	AMapEntry.listIterator()
ListIterator<ACell>	AMapEntry.listIterator(long index)
AVector<ACell>	AMapEntry.next()
Spliterator<ACell>	AMapEntry.spliterator(long position)
protected AHashMap<Keyword,ACell>	ARecord.toHashMap()	Converts this record to a HashMap
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 ABlobMap<K,V>	ABlobMap.assoc(ACell key, ACell value)	Associates a blob key with a value in this data structure.
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 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)
BlobMap<K,V>	BlobMap.assoc(ACell key, ACell value)
AHashMap<K,V>	MapLeaf.assoc(ACell key, ACell value)
MapTree<K,V>	MapTree.assoc(ACell key, ACell value)
static Hash	Hash.compute(ACell value)	Computes the Hash for any ACell value.
boolean	AHashSet.contains(ACell key)
abstract boolean	ASet.contains(ACell o)	Tests if this Set contains a given value
boolean	ABlobMap.containsKey(ACell key)
abstract boolean	ADataStructure.containsKey(ACell key)	Checks if the data structure contains the specified key
boolean	AMap.containsKey(ACell key)
boolean	ARecord.containsKey(ACell key)
boolean	ASequence.containsKey(ACell key)
boolean	ASet.containsKey(ACell key)
boolean	MapLeaf.containsKey(ACell key)
boolean	MapTree.containsKey(ACell key)
abstract boolean	AMap.containsValue(ACell value)	CHecks if this map contains the given value.
boolean	ARecord.containsValue(ACell value)
boolean	BlobMap.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)
final ABlobMap<K,V>	ABlobMap.dissoc(ACell key)
abstract AHashMap<K,V>	AHashMap.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.
AMap<Keyword,ACell>	ARecord.dissoc(ACell key)
MapLeaf<K,V>	MapLeaf.dissoc(ACell key)
AHashMap<K,V>	MapTree.dissoc(ACell key)
static Blob	Format.encodedBlob(ACell o)	Gets the encoded Blob for an object in canonical message format
static ByteBuffer	Format.encodedBuffer(ACell cell)	Gets an new encoded ByteBuffer for an Cell in wire format
static String	Format.encodedString(ACell cell)	Gets a hex String representing an object's encoding
static Blob	Format.encodeMultiCell(ACell a)	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 a)
boolean	ACell.equals(ACell a)	Checks for equality with another Cell.
boolean	Address.equals(ACell o)
boolean	ARecordGeneric.equals(ACell a)
boolean	Keyword.equals(ACell other)
boolean	MapEntry.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	StringShort.equals(ACell a)
boolean	Symbol.equals(ACell o)
boolean	VectorLeaf.equals(ACell a)
static int	Format.estimateEncodingSize(ACell cell)
SetLeaf<T>	SetLeaf.exclude(ACell key)
AHashSet<T>	SetTree.exclude(ACell key)
final V	ABlobMap.get(ACell key)
ACell	AccountStatus.get(ACell 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.
final CVMBool	AHashSet.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
abstract ACell	ARecord.get(ACell key)	Gets the record field content for a given key, or null if not found.
ACell	ARecordGeneric.get(ACell key)
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)
V	MapLeaf.get(ACell key)
V	MapTree.get(ACell key)
ACell	PeerStatus.get(ACell key)
ACell	SignedData.get(ACell key)
static int	Format.getEncodingLength(ACell value)
MapEntry<K,V>	ABlobMap.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)
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	Format.isEmbedded(ACell cell)	Determines if an object should be embedded directly in the encoding rather than referenced with a Ref / hash.
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
final ACell	AMapEntry.set(int index, ACell element)
static long	Refs.totalRefCount(ACell a)	Counts the total number of Refs contained in a data object recursively.
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	Refs.visitNonEmbedded(ACell a, Consumer<Ref<?>> visitor)	Visit all non-embedded children of a Cell.
AccountStatus	AccountStatus.withHolding(Address addr, ACell value)
static int	Format.write(byte[] bs, int pos, ACell cell)	Writes a cell encoding to a byte array, preceded by the appropriate tag
static ByteBuffer	Format.write(ByteBuffer bb, ACell cell)	Writes a canonical object to a ByteBuffer, 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(HashSet<Map.Entry<Keyword,ACell>> h)
protected void	ARecord.accumulateValues(ArrayList<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)
<T extends ACell> T	ACell.announce(Consumer<Ref<ACell>> noveltyHandler)
boolean	AMapEntry.anyMatch(Predicate<? super ACell> pred)
final AVector<ACell>	AMapEntry.appendChunk(VectorLeaf<ACell> listVector)
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 <T extends ACell> T	ACell.createAnnounced(T value, Consumer<Ref<ACell>> noveltyHandler)	Creates an ANNOUNCED Ref with the given value in the current store.
static <T extends ACell> Ref<T>	ACell.createPersisted(T value, Consumer<Ref<ACell>> noveltyHandler)	Creates a persisted Ref with the given value in the current store.
static Syntax	Syntax.createUnchecked(ACell value, AHashMap<ACell,ACell> meta)
static Syntax	Syntax.createUnchecked(ACell value, AHashMap<ACell,ACell> meta)
static Blob	Format.encodeDelta(List<ACell> cells)	Encode a list of cells as a delta message.
void	AMapEntry.forEach(Consumer<? super ACell> action)
void	ARecord.forEach(BiConsumer<? super Keyword,? super ACell> action)
MapEntry<K,V>	ABlobMap.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)
<T extends ACell> T	ACell.mark(Consumer<Ref<ACell>> noveltyHandler)
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)
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.

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

Modifier	Constructor	Description
protected	VectorArray(long count, T[] array, int offset, int stride)

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.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.
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 that return ACell

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

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

Modifier and Type	Method	Description
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	BlobMapType.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	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)
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)
ABlobMap	BlobMapType.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)
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.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.
class	Context<T extends ACell>	Representation of CVM execution context.
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 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 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 AFn<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 AFn<ACell>	Compiler.QUASIQUOTE_EXPANDER	Expander used for expansion of `quasiquote` forms.
static final AFn<ACell>	Core.QUASIQUOTE_EXPANDER
static final AFn<ACell>	Compiler.QUOTE_EXPANDER	Expander used for expansion of `quote` forms.
static final AFn<ACell>	Core.QUOTE_EXPANDER
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<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
<R extends ACell> Context<R>	Context.acceptFunds(long amount)	Accepts offered funds for the given address.
<R extends ACell> Context<R>	Context.actorCall(Address target, long offer, ACell functionName, ACell... args)	Executes a call to an Actor.
<R extends ACell> Context<R>	Context.actorCall(Address 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 <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.
<R extends ACell> Context<AOp<R>>	Context.compile(ACell expandedForm)	Compile a form in this Context.
<R extends ACell> Context<AVector<AOp<R>>>	Context.compileAll(ASequence<ACell> forms)	Compiles a sequence of forms in the current context.
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.
<R extends ACell> Context<R>	Context.consumeJuice(long gulp)	Consumes juice, returning an updated context if sufficient juice remains or an exceptional JUICE error.
static <R extends ACell> Context<R>	Context.createFake(State state)	Creates an execution context with a default actor address.
static <R extends ACell> Context<R>	Context.createFake(State state, Address origin)	Creates a "fake" execution context for the given address.
static <T extends ACell> Context<T>	Context.createInitial(State state, Address origin, long juice)	Creates an initial execution context with the specified actor as origin, and reserving the appropriate amount of juice.
<R extends ACell> Context<R>	Context.createPeer(AccountKey accountKey, long initialStake)	Creates a new peer with the specified stake.
static <T extends ACell> T	RT.cvm(Object o)	Converts a Java value to a CVM type.
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.
<R extends ACell> Context<R>	Context.eval(ACell form)	Executes a form in the current context.
<R extends ACell> Context<R>	Context.evalAs(Address address, ACell form)	Evaluates a form as another Address.
abstract <I extends ACell> Context<T>	AOp.execute(Context<I> context)	Executes this op with the given context.
<R extends ACell> Context<R>	Context.execute(AOp<R> op)	Executes an Op within this context, returning an updated context.
<I extends ACell> Context<I>	Context.executeLocalBinding(ACell bindingForm, AOp<I> op)	Execute an op, and bind the result to the given binding form in the lexical environment Binding form may be a destructuring form
<R extends ACell> Context<R>	Context.expand(AFn<?> expander, ACell form, AFn<?> cont)
<R extends ACell> Context<AOp<R>>	Context.expandCompile(ACell form)	Expand and compile a form in this Context.
<R extends ACell> Context<R>	Context.fork()	Forks this context, creating a new copy of all local state
<R extends ACell> Context<R>	Context.forkWithAddress(Address newAddress)	Switches the context to a new address, creating a new execution context.
protected <R extends ACell> Context<R>	Context.handleQueryResult(Context<R> ctx)	Just take result and juice from query.
<R extends ACell> Context<R>	Context.handleStateResults(Context<?> returnContext, boolean rollback)	Handle results at the end of an execution boundary (actor call, transaction etc.)
<R extends ACell> Context<R>	Context.invoke(AFn<R> fn, ACell... args)	Invokes a function within this context, returning an updated 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
<R extends ACell> Context<R>	Context.lookup(Symbol symbol)	Looks up a symbol's value in the current execution context, without any effect on the Context (no juice consumed etc.)
<R extends ACell> Context<R>	Context.lookupDynamic(Address address, Symbol symbol)	Looks up a value in the dynamic environment.
<R extends ACell> Context<R>	Context.lookupDynamic(Symbol symbol)	Looks up a value in the dynamic environment.
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.
<R extends ACell> Context<R>	Context.query(ACell form)	Executes code as if run in the current account, but always discarding state changes.
<R extends ACell> Context<R>	Context.queryAs(Address address, ACell form)	Executes code as if run in the specified account, but always discarding state changes.
static <T extends ACell> AOp<T>	Ops.read(Blob b, int pos)
static <T extends ACell> AOp<T>	Ops.read(ByteBuffer bb)	Reads an Op from the given ByteBuffer.
static <R extends ACell> R	Reader.read(String source)	Parses an expression and returns a canonical Cell representing a form
<R extends ACell> Context<R>	Context.run(ACell code)	Executes a form at the top level in a new forked Context.
<R extends ACell> Context<R>	Context.run(AOp<R> op)	Executes an Op at the top level in a new forked Context.
static <T extends ACell> ASequence<T>	RT.sequence(ACell o)	Converts any collection of cells into a Sequence data structure.
<R extends ACell> Context<R>	Context.setAccountKey(AccountKey publicKey)	Sets the public key for the current account
<R extends ACell> Context<R>	Context.setController(Address address)	Sets the controller for the current Account
<R extends ACell> Context<R>	Context.setDelegatedStake(AccountKey peerKey, long newStake)	Sets the delegated stake on a specified peer to the specified level.
<R extends ACell> Context<R>	Context.setPeerData(AccountKey peerKey, AHashMap<ACell,ACell> data)	Sets peer data.
<R extends ACell> Context<R>	Context.setPeerStake(AccountKey peerKey, long newStake)	Sets the stake for a given Peer, transferring coins from the current address.
<R extends ACell> Context<R>	Context.updateBindings(ACell bindingForm, Object args)	Updates local bindings with a given binding form
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
protected <R extends ACell> Context<R>	Context.withAccountStatus(Address target, AccountStatus accountStatus)
<R extends ACell> Context<R>	Context.withArgumentError(String message)
<R extends ACell> Context<R>	Context.withArityError(String message)
<R extends ACell> Context<R>	Context.withAssertError(String message)
<R extends ACell> Context<R>	Context.withBoundsError(long index)
<R extends ACell> Context<R>	Context.withCastError(int argIndex, ACell[] args, AType klass)
<R extends ACell> Context<R>	Context.withCastError(int argIndex, AType klass)
<R extends ACell> Context<R>	Context.withCastError(ACell a, AType klass)
<R extends ACell> Context<R>	Context.withCastError(ACell a, String message)
<R extends ACell> Context<R>	Context.withCastError(AType klass)
<R extends ACell> Context<R>	Context.withCompileError(String message)
<R extends ACell> Context<R>	Context.withCompilerState(Context.CompilerState comp)
<R extends ACell> Context<R>	Context.withError(Keyword error)
<R extends ACell> Context<R>	Context.withError(Keyword errorCode, ACell rs)
<R extends ACell> Context<R>	Context.withError(Keyword errorCode, String message)
<R extends ACell> Context<R>	Context.withError(ErrorValue error)
<R extends ACell> Context<R>	Context.withException(long gulp, AExceptional value)
<R extends ACell> Context<R>	Context.withException(AExceptional exception)
<R extends ACell> Context<R>	Context.withFundsError(String message)
<R extends ACell> Context<R>	Context.withJuice(long newJuice)
<R extends ACell> Context<R>	Context.withJuiceError()	Returns this context with a JUICE error, consuming all juice.
<R extends ACell> Context<R>	Context.withLocalBindings(AVector<ACell> newBindings)	Updates this Context with new local bindings.
<R extends ACell> Context<R>	Context.withResult(long gulp, R value)
<R extends ACell> Context<R>	Context.withResult(ACell value)	Returns a context updated with the specified result.
<R extends ACell> Context<R>	Context.withState(State newState)
<R extends ACell> Context<R>	Context.withValue(Object value)	Updates this context with a given value, which may either be a normal result or exceptional value

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
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	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
Context<ACell>	Context.expand(ACell form)	Expands a form with the default *initial-expander*
AHashMap<Symbol,ACell>	Context.getEnvironment()	Gets the current Environment
ABlobMap<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.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 expression list and 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.
<R extends ACell> Context<R>	Context.actorCall(Address target, long offer, ACell functionName, ACell... args)	Executes a call to an Actor.
<R extends ACell> Context<R>	Context.actorCall(Address 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 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.
<R extends ACell> Context<AOp<R>>	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	RT.count(ACell a)	Gets the count of elements in a countable data structure.
Context<T>	Context.define(Symbol key, ACell value)	Defines a value in the environment of the current address
Context<T>	Context.defineWithSyntax(Syntax syn, ACell value)	Defines a value in the environment of the current address, updating the metadata
Context<Address>	Context.deployActor(ACell code)	Deploys an Actor in this context.
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 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 CVMBool	RT.eq(ACell[] values)
<R extends ACell> Context<R>	Context.eval(ACell form)	Executes a form in the current context.
<R extends ACell> Context<R>	Context.evalAs(Address address, ACell form)	Evaluates a form as another Address.
<I extends ACell> Context<I>	Context.executeLocalBinding(ACell bindingForm, AOp<I> 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<ACell>	Context.expand(ACell form)	Expands a form with the default *initial-expander*
<R extends ACell> Context<R>	Context.expand(AFn<?> expander, ACell form, AFn<?> cont)
<R extends ACell> Context<AOp<R>>	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<T>	AFn.invoke(Context<ACell> context, ACell[] args)
<R extends ACell> Context<R>	Context.invoke(AFn<R> fn, ACell... args)	Invokes a function within this context, returning an updated context.
Context<T>	IFn.invoke(Context<ACell> 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.isCVM(ACell a)	Checks if a Cell is a valid CVM value
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 <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 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
<R extends ACell> Context<R>	Context.query(ACell form)	Executes code as if run in the current account, but always discarding state changes.
<R extends ACell> Context<R>	Context.queryAs(Address address, ACell form)	Executes code as if run in the specified account, but always discarding state changes.
<R extends ACell> Context<R>	Context.run(ACell code)	Executes a form at the top level in a new forked Context.
static <T extends ACell> ASequence<T>	RT.sequence(ACell o)	Converts any collection of cells into a Sequence data structure.
Context<T>	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
<R extends ACell> Context<R>	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
<R extends ACell> Context<R>	Context.withCastError(int argIndex, ACell[] args, AType klass)
<R extends ACell> Context<R>	Context.withCastError(ACell a, AType klass)
<R extends ACell> Context<R>	Context.withCastError(ACell a, String message)
<R extends ACell> Context<R>	Context.withError(Keyword errorCode, ACell rs)
<R extends ACell> Context<R>	Context.withResult(ACell value)	Returns a context updated with the specified result.

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

Modifier and Type	Method	Description
Context<T>	Context.appendLog(AVector<ACell> values)	Appends a log entry for the current address.
<R extends ACell> Context<AVector<AOp<R>>>	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
abstract Context<T>	AFn.invoke(Context<ACell> context, ACell[] args)
Context<T>	IFn.invoke(Context<ACell> context, ACell[] args)	Invoke this function in the given context.
Context<CVMLong>	Context.schedule(long time, AOp<ACell> op)	Schedules an operation for the specified future timestamp.
<R extends ACell> Context<R>	Context.setPeerData(AccountKey peerKey, AHashMap<ACell,ACell> data)	Sets peer data.
<R extends ACell> Context<R>	Context.setPeerData(AccountKey peerKey, AHashMap<ACell,ACell> data)	Sets peer data.
<R extends ACell> Context<R>	Context.withLocalBindings(AVector<ACell> newBindings)	Updates this Context with new local bindings.

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

Modifier	Constructor	Description
protected	Context(convex.core.lang.Context.ChainState chainState, long juice, AVector<ACell> localBindings2, T 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)
static <T extends ACell> Fn<T>	Fn.read(ByteBuffer bb)
static <T extends ACell> MultiFn<T>	MultiFn.read(Blob b, int pos)
static <T extends ACell> MultiFn<T>	MultiFn.read(ByteBuffer bb)
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.
Context<T>	ADataFn.invoke(Context<ACell> context, ACell[] args)
abstract Context<T>	CoreFn.invoke(Context<ACell> context, ACell[] args)
Context<CVMBool>	CorePred.invoke(Context context, ACell[] args)
Context<T>	Fn.invoke(Context context, ACell[] args)
Context<T>	KeywordFn.invoke(Context context, ACell[] args)
Context<T>	MapFn.invoke(Context context, ACell[] args)
Context<T>	MultiFn.invoke(Context<ACell> context, ACell[] args)
Context<T>	SeqFn.invoke(Context context, ACell[] args)
Context<CVMBool>	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)
Context<T>	ADataFn.invoke(Context<ACell> context, ACell[] args)
abstract Context<T>	CoreFn.invoke(Context<ACell> context, ACell[] args)
Context<T>	MultiFn.invoke(Context<ACell> context, ACell[] args)
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> 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, 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)
<I extends ACell> Context<T>	Cond.execute(Context<I> context)
<I extends ACell> Context<T>	Constant.execute(Context<I> context)
<I extends ACell> Context<T>	Def.execute(Context<I> context)
<I extends ACell> Context<T>	Do.execute(Context<I> context)
<I extends ACell> Context<T>	Invoke.execute(Context<I> context)
<I extends ACell> Context<AClosure<T>>	Lambda.execute(Context<I> context)
<I extends ACell> Context<T>	Let.execute(Context<I> context)
<R extends ACell> Context<T>	Local.execute(Context<R> context)
<I extends ACell> Context<T>	Lookup.execute(Context<I> context)
<I extends ACell> Context<T>	Query.execute(Context<I> context)
<R extends ACell> Context<T>	Set.execute(Context<R> context)
<R extends ACell> Context<T>	Special.execute(Context<R> context)
static <R extends ACell> Special<R>	Special.forSymbol(Symbol sym)	Gets the special Op for a given Symbol, or null if not found
<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> Cond<T>	Cond.read(Blob b, int pos)
static <T extends ACell> Cond<T>	Cond.read(ByteBuffer b)
static <T extends ACell> Constant<T>	Constant.read(Blob b, int pos)
static <T extends ACell> Constant<T>	Constant.read(ByteBuffer bb)
static <T extends ACell> Def<T>	Def.read(Blob b, int pos)
static <T extends ACell> Def<T>	Def.read(ByteBuffer b)
static <T extends ACell> Do<T>	Do.read(Blob b, int pos)
static <T extends ACell> Do<T>	Do.read(ByteBuffer b)
static <T extends ACell> Invoke<T>	Invoke.read(Blob b, int pos)
static <T extends ACell> Invoke<T>	Invoke.read(ByteBuffer bb)
static <T extends ACell> Lambda<T>	Lambda.read(Blob b, int pos)
static <T extends ACell> Lambda<T>	Lambda.read(ByteBuffer bb)
static <T extends ACell> Let<T>	Let.read(Blob b, int pos, boolean isLoop)
static <T extends ACell> Let<T>	Let.read(ByteBuffer b, boolean isLoop)
static <R extends ACell> Local<R>	Local.read(Blob b, int pos)
static <R extends ACell> Local<R>	Local.read(ByteBuffer bb)
static <T extends ACell> Lookup<T>	Lookup.read(Blob b, int pos)
static <T extends ACell> Lookup<T>	Lookup.read(ByteBuffer bb)
static <T extends ACell> Query<T>	Query.read(Blob b, int pos)
static <T extends ACell> Query<T>	Query.read(ByteBuffer b)
static <R extends ACell> Set<R>	Set.read(Blob b, int pos)
static <R extends ACell> Set<R>	Set.read(ByteBuffer bb)

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, 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 that return ACell

Modifier and Type	Method	Description
ACell	AntlrReader.CRListener.pop()
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
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)
<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
final ACell	AStore.decode(Blob encoding)	Decodes a Cell from an Encoding.

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

Modifier and Type	Method	Description
void	BlobCache.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
abstract <T extends ACell> Context<T>	ATransaction.apply(Context<?> ctx)	Applies the functional effect of this transaction to the current state.
<T extends ACell> Context<T>	Call.apply(Context<?> ctx)
<T extends ACell> Context<T>	Invoke.apply(Context<?> context)
<T extends ACell> Context<T>	Multi.apply(Context<?> ctx)
<T extends ACell> Context<T>	Transfer.apply(Context<?> ctx)
<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)

Methods in convex.core.transactions that return ACell

Modifier and Type	Method	Description
ACell	Call.get(ACell key)
ACell	Invoke.get(ACell key)
ACell	Multi.get(ACell key)
ACell	Transfer.get(ACell key)

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)
ACell	Call.get(ACell key)
ACell	Invoke.get(ACell key)
ACell	Multi.get(ACell key)
ACell	Transfer.get(ACell key)

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> L, Function<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<T,U> value, Comparator<U> comparator, U target)	Leftmost Binary Search.
static <R extends ACell> Ref<R>	Utils.getRef(ACell o, int i)
static <T extends ACell> T	Utils.updateRefs(T o, IRefFunction func)

Methods in convex.core.util that return ACell

Modifier and Type	Method	Description
static ACell[]	Utils.toCellArray(Object anyArray)	Converts any array to an ACell[] array.

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
static <R extends ACell> Ref<R>	Utils.getRef(ACell o, int i)
static int	Utils.refCount(ACell a)	Gets the number of Refs directly contained in a Cell (will be zero if the Cell is not a Ref container)

Uses of ACell in etch

Methods in etch with type parameters of type ACell

Modifier and Type	Method	Description
<T extends ACell> Ref<T>	EtchStore.checkCache(Hash h)
<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
RefSoft<ACell>	Etch.read(AArrayBlob key)	Reads a Blob from the database, returning null if not found
Ref<ACell>	Etch.write(AArrayBlob key, Ref<ACell> value)	Writes a key / value pair to the immutable store.

Method parameters in etch with type arguments of type ACell

Modifier and Type	Method	Description
void	EtchStore.mark(Collection<ACell> roots, Consumer<Ref<ACell>> handler)	Mark GC roots for retention during garbage collection
void	EtchStore.mark(Collection<ACell> roots, Consumer<Ref<ACell>> handler)	Mark GC roots for retention during garbage collection
<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.