package util
- Alphabetic
- By Inheritance
- util
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait BatchAggregator[A, B] extends AnyRef
This batch aggregator exposes a BatchAggregator.run method that allows for batching scala.concurrent.Future computations, defined by a BatchAggregator.Processor.
This batch aggregator exposes a BatchAggregator.run method that allows for batching scala.concurrent.Future computations, defined by a BatchAggregator.Processor.
Note: it is required that
getter
andbatchGetter
do not throw an exception. If they do, the number of in-flight requests could fail to be decremented which would result in degraded performance or even prevent calls to the getters. - class BatchAggregatorImpl[A, B] extends BatchAggregator[A, B]
- sealed abstract class Checked[+A, +N, +R] extends Product with Serializable
A monad for aborting and non-aborting errors.
A monad for aborting and non-aborting errors. Non-aborting errors are accumulated in a cats.data.Chain until the first aborting error is hit. You can think of com.digitalasset.canton.util.Checked as an extension of
Either
to also support errors that should not cause the computation to abort.- A
Type of aborting errors
- N
Type of non-aborting errors
- R
Result type of the monad
- final case class CheckedT[F[_], A, N, R](value: F[Checked[A, N, R]]) extends Product with Serializable
Monad Transformer for Checked, allowing the effect of a monad
F
to be combined with the aborting and non-aborting failure effect of Checked.Monad Transformer for Checked, allowing the effect of a monad
F
to be combined with the aborting and non-aborting failure effect of Checked. Similar to cats.data.EitherT. - trait CheckedTInstances extends AnyRef
- trait CheckedTInstances1 extends AnyRef
- type ErrorLoggingLazyVal[T] = LazyValWithContext[T, ErrorLoggingContext]
- trait HasFlushFuture extends NamedLogging
Provides a single flush scala.concurrent.Future that runs asynchronously.
Provides a single flush scala.concurrent.Future that runs asynchronously. Tasks can be chained onto the flush future, although they will not run sequentially.
- final class LazyValWithContext[T, Context] extends AnyRef
"Implements" a
lazy val
field whose initialization expression can refer to implicit context information of typeContext
."Implements" a
lazy val
field whose initialization expression can refer to implicit context information of typeContext
. The "val" is initialized upon the first call to get, using the context information supplied for this call, like alazy val
.Instead of a plain lazy val field without context
class C { lazy val f: T = initializer }
use the following code to pass in aContext
:class C { private[this] val _f: LazyValWithContext[T, Context] = new LazyValWithContext[T, Context](context => initializer) def f(implicit context: Context): T = _f.get }
This class implements the same scheme as how the Scala 2.13 compiler implements
lazy val
s, as explained on https://docs.scala-lang.org/sips/improved-lazy-val-initialization.html (version V1) along with its caveats.- See also
TracedLazyVal To be used when the initializer wants to log something using the logger of the surrounding class
ErrorLoggingLazyVal To be used when the initializer wants to log errors using the logger of the caller
- trait LazyValWithContextCompanion[Context] extends AnyRef
- class MessageRecorder extends FlagCloseable with NamedLogging
Persists data for replay tests.
- trait NoCopy extends AnyRef
Prevents auto-generation of the copy method in a case class.
Prevents auto-generation of the copy method in a case class. Case classes with private constructors typically shouldn't have a copy method.
- class NoOpBatchAggregator[A, B] extends BatchAggregator[A, B]
- class RateLimiter extends AnyRef
Utility class that allows clients to keep track of a rate limit.
Utility class that allows clients to keep track of a rate limit. Clients need to tell an instance whenever they intend to start a new task. The instance will inform the client whether the task can be executed while still meeting the rate limit.
Guarantees:
- Maximum burst size: if
checkAndUpdateRate
is calledn
times in parallel, at mostmax(2, maxTasksPerSecond / 5)
calls may returntrue
. The upper bound mainly comes from the assumption thatSystem.nanoTime
has a resolution of100.millis
. - Average rate: if
checkAndUpdateRate
is called at a rate of at leastmaxTasksPerSecond
duringn
seconds, then the number of calls that returntrue
divided byn
is roughlymaxTasksPerSecond
whenn
goes towards infinity. See the unit tests to get a better understanding of the term "roughly".
- Maximum burst size: if
- trait ShowUtil extends ShowSyntax
- class SimpleExecutionQueue extends PrettyPrinting
Functions executed with this class will only run when all previous calls have completed executing.
Functions executed with this class will only run when all previous calls have completed executing. This can be used when async code should not be run concurrently.
- class SingleUseCell[A] extends AnyRef
This class provides a mutable container for a single value of type
A
.This class provides a mutable container for a single value of type
A
. The value may be put at most once. A SingleUseCell therefore provides the following immutability guarantee: The value of a cell cannot change; once it has been put there, it will remain in the cell. - class SnapshottableList[A] extends AnyRef
A mutable list to which elements can be prepended and where snapshots can be taken atomically.
A mutable list to which elements can be prepended and where snapshots can be taken atomically. Both operations are constant-time. Thread safe.
- trait Thereafter[F[_], Content[A]] extends Any
Typeclass for computations with an operation that can run a side effect after the computation has finished.
Typeclass for computations with an operation that can run a side effect after the computation has finished.
The typeclass abstracts the following pattern so that it can be used for types other than scala.concurrent.Future.
future.transform { result => val () = body(result); result }
- F
The computation's type functor.
- Content
The container type for computation result. Functionally dependent on
F
.
- type TracedLazyVal[T] = LazyValWithContext[T, TraceContext]
- case class UByte(signed: Byte) extends NoCopy with Product with Serializable
Value Members
- val ErrorLoggingLazyVal: LazyValWithContextCompanion[ErrorLoggingContext]
- val TracedLazyVal: LazyValWithContextCompanion[TraceContext]
- object AkkaUtil
- object BatchAggregator
- object BinaryFileUtil
Write and read byte strings to files.
- object ByteArrayUtil
- object ByteStringImplicits
- object ByteStringUtil
- object ChainUtil
Provides utility functions for the
cats
implementation of aChain
.Provides utility functions for the
cats
implementation of aChain
. This is a data-structure similar to a List, with constant time prepend and append. Note that theChain
has a performance hit when pattern matching as there is no constant-time uncons operation.Documentation on the
cats
Chain
: https://typelevel.org/cats/datatypes/chain.html. - object Checked extends Serializable
- object CheckedT extends CheckedTInstances with Serializable
- object DamlPackageLoader
Wrapper that retrieves parsed packages from a DAR file consumable by the Daml interpreter.
- object DelayUtil extends NamedLogging
Utility to create futures that succeed after a given delay.
Utility to create futures that succeed after a given delay.
Inspired by the odelay library, but with a restricted interface to avoid hazardous effects that could be caused by the use of a global executor service.
TODO(i4245): Replace all usages by Clock.
- object EitherTUtil
Utility functions for the
cats
cats.data.EitherT monad transformer.Utility functions for the
cats
cats.data.EitherT monad transformer. https://typelevel.org/cats/datatypes/eithert.html - object EitherUtil
- object ErrorUtil
- object FutureUtil
- object HasFlushFuture
- object HexString
Conversion functions to and from hex strings.
- object IdUtil
Contains instances for the
Id
functor. - object IterableUtil
- object LfTransactionUtil
Helper functions to work with
com.digitalasset.daml.lf.transaction.GenTransaction
.Helper functions to work with
com.digitalasset.daml.lf.transaction.GenTransaction
. Using these helper functions is useful to provide a buffer from upstream changes. - object LoggerUtil
- object MapsUtil
- object MessageRecorder
- object MonadUtil
- object OptionUtil
- object PathUtils
- object PriorityBlockingQueueUtil
- object RangeUtil
- object ResourceUtil
Utility code for doing proper resource management.
Utility code for doing proper resource management. A lot of it is based on https://medium.com/@dkomanov/scala-try-with-resources-735baad0fd7d
- object SetsUtil
- object ShowUtil extends ShowUtil
Utility class for clients who want to make use of pretty printing.
Utility class for clients who want to make use of pretty printing. Import this as follows:
import com.digitalasset.canton.util.ShowUtil._
In some cases, an import at the top of the file will not make theshow
interpolator available. To work around this, you need to import this INSIDE of the using class.To enforce pretty printing, the
show
interpolator should be used for creating strings. That is,show"s$myComplexObject"
will result in a compile error, if pretty printing is not implemented formyComplexObject
. In contrast,s"$myComplexObject"
will fall back to the default (non-pretty) toString implementation, if pretty printing is not implemented formyComplexObject
. Even if pretty printing is implemented for the typeT
ofmyComplexObject
,s"$myComplexObject"
will not use it, if the compiler fails to inferT: Pretty
. - object SimpleExecutionQueue
- object SnapshottableList
- object StackTraceUtil
- object TextFileUtil
- object Thereafter
- object TraversableUtil
- object TrieMapUtil
- object TryUtil
- object UByte extends Serializable