Uses of Class
convex.core.data.ACell

Packages that use ACell

Package	Description
convex.core
convex.core.crypto
convex.core.data	Data structures and algorithms, including a complete set of classes required to implement immutable, decentralised data objects.
convex.core.data.prim
convex.core.data.type
convex.core.exceptions
convex.core.lang
convex.core.lang.impl
convex.core.lang.ops
convex.core.lang.reader
convex.core.store
convex.core.transactions
convex.core.util
etch

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.
class	Block	A block contains an ordered collection of signed transactions that may be applied collectively as part of a state update.
class	BlockResult	Class representing the result of applying a Block to a State.
class	Order	Class representing an Ordering of transactions, along with the consensus position.
class	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 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>	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	State.get(ACell k)
ACell	Result.getErrorCode()	Returns the Error Code from this Result.
ACell	Result.getID()	Returns the message ID for this result.
ACell	Order.toCanonical()

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.
static AMap<Keyword,ACell>	Peer.getPeerData(AStore store)	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 Datat 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, ACell trace)	Create a Result
<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.
ACell	Belief.get(ACell k)
ACell	Block.get(ACell k)
ACell	BlockResult.get(ACell key)
ACell	State.get(ACell k)
protected Belief	Belief.updateAll(ACell[] newVals)
protected Block	Block.updateAll(ACell[] newVals)
protected BlockResult	BlockResult.updateAll(ACell[] newVals)
protected State	State.updateAll(ACell[] newVals)
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
boolean	Belief.equals(AMap<Keyword,ACell> a)
boolean	Block.equals(AMap<Keyword,ACell> a)
boolean	BlockResult.equals(AMap<Keyword,ACell> a)
boolean	State.equals(AMap<Keyword,ACell> a)
static Peer	Peer.fromData(AKeyPair keyPair, AMap<Keyword,ACell> peerData)	Constructs a Peer instance from persisted PEer Data
Peer	Peer.persistState(Consumer<Ref<ACell>> noveltyHandler)	Persist the state of the Peer to the current store.
protected ARecord	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 dtata 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
<R extends ACell> SignedData<R>	Ed25519KeyPair.signData(R value)

Methods in convex.core.crypto that return ACell

Modifier and Type	Method	Description
ACell	Ed25519Signature.toCanonical()

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 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 persistent lists and vectors
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 object.
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.
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	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 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.
class	Address	Immutable class representing an Address.
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	ANumericBlob	Base class for Blobs which represent an integral numeric value
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 persistent lists and vectors
class	ASet<T extends ACell>	Abstract based class for sets.
class	AString	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.
class	LongBlob	Wrapper for an 8-byte long blob We use this 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.
class	SignedData<T extends ACell>	Node representing a signed data object.
class	StringShort	Class representing a short CVM string.
class	StringSlice	AString subclass representing a subsequence of another charsequence
class	StringTree
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 ACell[]	ACell.EMPTY_ARRAY	An empty Java array of cells

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

Modifier and Type	Field	Description
protected Ref<ACell>	ACell.cachedRef	Cached Ref.
static 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)
<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(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 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 ListMap 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> RefDirect<T>	RefDirect.create(T value, Hash hash)	Creates a direct Ref to the given value
static <T extends ACell> RefDirect<T>	RefDirect.create(T value, Hash hash, int status)	Construction function for a Direct Ref
static <T extends ACell> RefSoft<T>	RefSoft.create(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(ADataStructure<T> source)	Creates a set of all the elements in the given data structure
static <V extends ACell> SetTree<V>	SetTree.create(Ref<V>[] newEntries, int shift)
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 ListVector 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, T extends ACell> AVector<R>	Vectors.create(ASequence<R> list)
static <R extends ACell, T extends ACell> AVector<R>	Vectors.create(ASequence<R> list)
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 <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(Object value)
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)
<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>	ARecord.getRef(int index)
<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>	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)
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(ByteBuffer bb)
static <T extends ACell> T	Format.read(byte tag, Blob blob)	Read from a Blob with the specified tag
static <T extends ACell> T	Format.read(Blob blob)	Decodes a single Value from a Blob.
static <T extends ACell> T	Format.read(String hexString)	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(ByteBuffer bb)	Reads a List from the specified bytebuffer.
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.read(ByteBuffer bb)	Reads a MapEntry from a ByteBuffer.
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.read(ByteBuffer bb)	Reads a MapEntry from a ByteBuffer.
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(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(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(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(ByteBuffer bb)
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(ByteBuffer data)	Reads a SignedData instance from the given ByteBuffer
static <T extends ACell> VectorLeaf<T>	VectorLeaf.read(ByteBuffer bb, long count)	Reads a ListVector from the provided ByteBuffer Assumes the header byte and count is already read.
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(ByteBuffer bb, long count)	Reads a VectorTree from the provided ByteBuffer Assumes the header byte and count is already read.
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.readCompressed(ByteBuffer bb)	Reads a MapEntry or null from a ByteBuffer.
static <K extends ACell, V extends ACell> MapEntry<K,V>	MapEntry.readCompressed(ByteBuffer bb)	Reads a MapEntry or null from a ByteBuffer.
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(ByteBuffer bb)	Reads a Ref 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()
<R extends ACell> AVector<R>	VectorLeaf.toVector()
<R extends ACell> AVector<R>	VectorTree.toVector()
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> 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
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.
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	AccountStatus.getHolding(Address addr)
ACell[]	ARecord.getValuesArray()	Gets an array containing all values in this record, in format-defined key order.
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	SignedData.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)
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()
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> ref)
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<Keyword,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
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)
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 ListVector 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)
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
boolean	ABlob.equals(ACell o)	Determines if this Blob is equal to another Object.
boolean	ACell.equals(ACell a)	Checks for equality with another object.
boolean	AMap.equals(ACell a)
boolean	ASet.equals(ACell o)
boolean	Keyword.equals(ACell other)
boolean	MapEntry.equals(ACell o)
boolean	StringShort.equals(ACell a)
boolean	Symbol.equals(ACell o)
boolean	VectorLeaf.equals(ACell a)
static int	Format.estimateSize(ACell cell)
SetLeaf<T>	SetLeaf.exclude(ACell key)
AHashSet<T>	SetTree.exclude(ACell key)
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.
CVMBool	AHashSet.get(ACell key)
abstract V	AMap.get(ACell key)
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)
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.
ACell	AMapEntry.set(int index, ACell element)
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
protected AccountStatus	AccountStatus.updateAll(ACell[] newVals)
protected abstract ARecord	ARecord.updateAll(ACell[] newVals)	Updates all values in this record, in declared field order.
protected ARecord	ARecordGeneric.updateAll(ACell[] newVals)
protected PeerStatus	PeerStatus.updateAll(ACell[] newVals)
AccountStatus	AccountStatus.withHolding(Address addr, ACell value)
static int	Format.write(byte[] bs, int pos, ACell cell)	Writes a canonical object 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)
AVector<ACell>	AMapEntry.appendChunk(VectorLeaf<ACell> listVector)
AMap<Keyword,ACell>	ARecord.assocEntry(MapEntry<Keyword,ACell> e)
long	AMapEntry.commonPrefixLength(AVector<ACell> b)
boolean	AMap.containsKeyRef(Ref<ACell> ref)
static PeerStatus	PeerStatus.create(Address controller, long stake, AHashMap<Keyword,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)
boolean	AccountStatus.equals(AMap<Keyword,ACell> a)
boolean	ARecordGeneric.equals(AMap<Keyword,ACell> a)
boolean	PeerStatus.equals(AMap<Keyword,ACell> a)
boolean	ARecord.equalsKeys(AMap<Keyword,ACell> map)
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> ref)
MapEntry<K,V>	MapLeaf.getKeyRefEntry(Ref<ACell> ref)
MapEntry<K,V>	MapTree.getKeyRefEntry(Ref<ACell> ref)
<R extends ACell> AVector<R>	MapEntry.map(Function<? super ACell,? extends R> mapper)
Syntax	Syntax.mergeMeta(AHashMap<ACell,ACell> additionalMetadata)	Merges metadata into this syntax object, overriding existing metadata
Syntax	Syntax.mergeMeta(AHashMap<ACell,ACell> additionalMetadata)	Merges metadata into this syntax object, overriding existing metadata
<R extends ACell> Ref<R>	Ref.persist(Consumer<Ref<ACell>> noveltyHandler)	Persists this Ref in the current store if not embedded and not already persisted.
<R extends ACell> Ref<R>	Ref.persistShallow(Consumer<Ref<ACell>> noveltyHandler)	Persists a Ref shallowly in the current store.
<R> R	MapEntry.reduce(BiFunction<? super R,? super ACell,? extends R> func, R value)
<R> R	ARecord.reduceEntries(BiFunction<? super R,MapEntry<Keyword,ACell>,? extends R> func, R initial)
<R> R	ARecord.reduceValues(BiFunction<? super R,? super ACell,? extends R> func, R initial)
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)
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	APrimitive	Abstract base class for small CVM primitive values.
class	CVMBool	Class for CVM Boolean types.
class	CVMByte	Class for CVM Byte instances.
class	CVMChar	Class for CVM character values.
class	CVMDouble	Class for CVM double floating-point values.
class	CVMLong	Class for CVM long values.

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

Modifier and Type	Method	Description
protected <R extends ACell> Ref<R>	APrimitive.createRef()

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

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

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	Byte.check(ACell value)
boolean	CharacterType.check(ACell value)
boolean	Collection.check(ACell value)
boolean	DataStructure.check(ACell value)
boolean	Double.check(ACell value)
boolean	Function.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)
CVMByte	Byte.implicitCast(ACell a)
CVMChar	CharacterType.implicitCast(ACell a)
ACollection<?>	Collection.implicitCast(ACell a)
ADataStructure<?>	DataStructure.implicitCast(ACell a)
CVMDouble	Double.implicitCast(ACell a)
AFn	Function.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)
APrimitive	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 CoreFn<ADataStructure<ACell>>	Core.ASSOC
static CoreFn<ACell>	Core.ASSOC_IN
static CoreFn<ACell>	Core.CALL_STAR
static CoreFn<AOp<ACell>>	Core.COMPILE
static CoreFn<ASequence<ACell>>	Core.CONCAT
static CoreFn<ADataStructure<ACell>>	Core.CONJ
static CoreFn<AList<ACell>>	Core.CONS
static CoreFn<ASet<ACell>>	Core.DIFFERENCE
static CoreFn<ASet<ACell>>	Core.DISJ
static CoreFn<ACell>	Core.EMPTY
static AVector<ACell>	Context.EMPTY_BINDINGS
static AHashMap<Symbol,ACell>	Core.ENVIRONMENT	Default initial environment importing core namespace
static CoreFn<ACell>	Core.EVAL
static CoreFn<ACell>	Core.EVAL_AS
static CoreFn<ACell>	Core.EXPAND
static CoreFn<ACell>	Core.FIRST
static CoreFn<ACell>	Core.GET
static CoreFn<ACell>	Core.GET_HOLDING
static CoreFn<ACell>	Core.GET_IN
static AFn<ACell>	Compiler.INITIAL_EXPANDER	Initial expander used for expansion of forms prior to compilation.
static AFn<ACell>	Core.INITIAL_EXPANDER
static CoreFn<ASet<ACell>>	Core.INTERSECTION
static CoreFn<ADataStructure<ACell>>	Core.INTO
static CoreFn<AVector<ACell>>	Core.KEYS
static CoreFn<ACell>	Core.LAST
static CoreFn<AList<ACell>>	Core.LIST
static CoreFn<ACell>	Core.LOOKUP
static CoreFn<AHashMap<ACell,ACell>>	Core.MERGE
static CoreFn<AHashMap<ACell,ACell>>	Core.MERGE
static CoreFn<AHashMap<ACell,ACell>>	Core.META
static CoreFn<AHashMap<ACell,ACell>>	Core.META
static AHashMap<Symbol,AHashMap<ACell,ACell>>	Core.METADATA	Default initial core metadata
static AHashMap<Symbol,AHashMap<ACell,ACell>>	Core.METADATA	Default initial core metadata
static CoreFn<ASequence<ACell>>	Core.NEXT
static CoreFn<ACell>	Core.NTH
static AFn<ACell>	Compiler.QUASIQUOTE_EXPANDER	Expander used for expansion of `quasiquote` forms.
static AFn<ACell>	Core.QUASIQUOTE_EXPANDER
static AFn<ACell>	Compiler.QUOTE_EXPANDER	Expander used for expansion of `quote` forms.
static AFn<ACell>	Core.QUOTE_EXPANDER
static CoreFn<ACell>	Core.REDUCE
static CoreFn<ACell>	Core.REDUCED
static CoreFn<AVector<ACell>>	Core.REVERSE
static CoreFn<ACell>	Core.SECOND
static CoreFn<ASet<ACell>>	Core.SET
static CoreFn<ACell>	Core.SET_CONTROLLER
static CoreFn<ACell>	Core.SET_HOLDING
static CoreFn<ACell>	Core.UNDEF_STAR
static CoreFn<ASet<ACell>>	Core.UNION
static CoreFn<ACell>	Core.UNSYNTAX
static CoreFn<AVector<ACell>>	Core.VALUES
static CoreFn<AVector<ACell>>	Core.VEC
static 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 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.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 the vector of keys of a map, or null if the object is not a 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(ByteBuffer bb)	Reads an Op from the given ByteBuffer.
static <R extends ACell> R	Reader.read(String source)	Parses an expression and returns 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, AMap<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, 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	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 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 CVMByte	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 Keyword	RT.castKeyword(ACell a)	Coerces an named argument 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 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.
static CVMLong	RT.dec(ACell x)	Decrements a Long value
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 IAssociative instance.
static ABlob	RT.ensureBlob(ACell object)	Implicitly casts the argument to a Blob
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 Long 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 CVMLong	RT.ensureLong(ACell a)	Ensures the argument is a CVM Long value.
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 INumeric	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)	Implicitly casts the argument to a CVM String
static Symbol	RT.ensureSymbol(ACell a)	Coerces an named argument to a Symbol.
static Boolean	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 Boolean	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 Boolean	RT.gt(ACell[] values)
static CVMLong	RT.inc(ACell x)	Increments a Long value
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.isNaN(ACell val)
static boolean	RT.isNumber(ACell val)	Tests if a Value is a valid numerical value
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 the vector of keys of a map, or null if the object is not a map
static Boolean	RT.le(ACell[] values)
AFn<ACell>	Context.lookupExpander(ACell form)	Looks up an expander from a form in this context
static Boolean	RT.lt(ACell[] values)
static APrimitive	RT.minus(ACell[] args)
static APrimitive	RT.minusDouble(ACell[] args)
static CVMLong	RT.mod(ACell a, ACell b)	Compute mode.
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 APrimitive	RT.plus(ACell[] args)
static CVMDouble	RT.plusDouble(ACell[] args)
static CVMDouble	RT.pow(ACell[] args)	Computes the result of a pow operation.
<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 String	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 APrimitive	RT.times(ACell[] args)
static APrimitive	RT.timesDouble(ACell[] args)
static CVMChar	RT.toCharacter(ACell a)	Casts a value to a Character
<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.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.
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, AMap<ACell,ACell> data)	Sets peer data.
<R extends ACell> Context<R>	Context.setPeerData(AccountKey peerKey, AMap<ACell,ACell> data)	Sets peer data.
<R extends ACell> Context<R>	Context.withLocalBindings(AVector<ACell> newBindings)	Updates this Context with new local bindings.

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 ACell[]	ATrampoline.args

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

Modifier and Type	Field	Description
protected 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(ByteBuffer bb)
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)
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 "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>

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 "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>

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

Modifier and Type	Field	Description
protected AVector<AOp<ACell>>	AMultiOp.ops
protected 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 <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 <R extends ACell> Set<R>	Set.create(long position, AOp<R> op)	Creates special 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)
<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(ByteBuffer b)
static <T extends ACell> AOp<T>	Constant.read(ByteBuffer bb)
static <T extends ACell> Def<T>	Def.read(ByteBuffer b)
static <T extends ACell> Do<T>	Do.read(ByteBuffer b)
static <T extends ACell> Invoke<T>	Invoke.read(ByteBuffer bb)
static <T extends ACell> Lambda<T>	Lambda.read(ByteBuffer bb)
static <T extends ACell> Let<T>	Let.read(ByteBuffer b, boolean isLoop)
static <R extends ACell> Local<R>	Local.read(ByteBuffer bb)
static <T extends ACell> Lookup<T>	Lookup.read(ByteBuffer bb)
static <T extends ACell> Query<T>	Query.read(ByteBuffer b)
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
<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.
<T extends ACell> Ref<T>	MemoryStore.refForHash(Hash hash)
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
ACell	AStore.decode(ABlob encoding)	Decodes a Cell from an Encoding.
ACell	BlobCache.getCell(ABlob encoding)	Gets the Cached Cell for a given Blob Encoding, or null if not cached.

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

Modifier and Type	Method	Description
void	BlobCache.putCell(ACell cell)	Stores a cell 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	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 ACell	Invoke.command

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

Modifier and Type	Field	Description
protected 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>	Transfer.apply(Context<?> ctx)
<T extends ACell> Ref<T>	Call.getRef(int i)
<R extends ACell> Ref<R>	Invoke.getRef(int i)

Methods in convex.core.transactions that return ACell

Modifier and Type	Method	Description
ACell	ATransaction.toCanonical()
ACell	Call.updateRefs(IRefFunction func)

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

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

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> 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.refForHash(Hash hash)
<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, Consumer<Ref<ACell>> noveltyHandler, int requiredStatus, boolean topLevel)
<T extends ACell> Ref<T>	EtchStore.storeTopRef(Ref<T> ref, int status, Consumer<Ref<ACell>> noveltyHandler)

Methods in etch that return types with arguments of type ACell

Modifier and Type	Method	Description
Ref<ACell>	Etch.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
<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, Consumer<Ref<ACell>> noveltyHandler, int requiredStatus, 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.