Package com.daml.ledger.api.v1

Class TransactionOuterClass.TransactionTree.Builder

    • Method Detail

      • getDescriptor

        public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

      • internalGetMapField

        protected com.google.protobuf.MapField internalGetMapField​(int number)
        Overrides:
        internalGetMapField in class com.google.protobuf.GeneratedMessageV3.Builder<TransactionOuterClass.TransactionTree.Builder>

      • internalGetMutableMapField

        protected com.google.protobuf.MapField internalGetMutableMapField​(int number)
        Overrides:
        internalGetMutableMapField in class com.google.protobuf.GeneratedMessageV3.Builder<TransactionOuterClass.TransactionTree.Builder>

      • internalGetFieldAccessorTable

        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
        Specified by:
        internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessageV3.Builder<TransactionOuterClass.TransactionTree.Builder>

      • getDescriptorForType

        public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
        Specified by:
        getDescriptorForType in interface com.google.protobuf.Message.Builder
        Specified by:
        getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
        Overrides:
        getDescriptorForType in class com.google.protobuf.GeneratedMessageV3.Builder<TransactionOuterClass.TransactionTree.Builder>

      • getDefaultInstanceForType

        public TransactionOuterClass.TransactionTree getDefaultInstanceForType()
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

      • build

        public TransactionOuterClass.TransactionTree build()
        Specified by:
        build in interface com.google.protobuf.Message.Builder
        Specified by:
        build in interface com.google.protobuf.MessageLite.Builder

      • buildPartial

        public TransactionOuterClass.TransactionTree buildPartial()
        Specified by:
        buildPartial in interface com.google.protobuf.Message.Builder
        Specified by:
        buildPartial in interface com.google.protobuf.MessageLite.Builder

      • isInitialized

        public final boolean isInitialized()
        Specified by:
        isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
        Overrides:
        isInitialized in class com.google.protobuf.GeneratedMessageV3.Builder<TransactionOuterClass.TransactionTree.Builder>

      • mergeFrom

        public TransactionOuterClass.TransactionTree.Builder mergeFrom​(com.google.protobuf.CodedInputStream input,
                                                               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                        throws java.io.IOException
        Specified by:
        mergeFrom in interface com.google.protobuf.Message.Builder
        Specified by:
        mergeFrom in interface com.google.protobuf.MessageLite.Builder
        Overrides:
        mergeFrom in class com.google.protobuf.AbstractMessage.Builder<TransactionOuterClass.TransactionTree.Builder>
        Throws:
        java.io.IOException

      • getTransactionId

        public java.lang.String getTransactionId()
         Assigned by the server. Useful for correlating logs.
 Must be a valid LedgerString (as described in ``value.proto``).
 Required
        string transaction_id = 1 [json_name = "transactionId"];
        Specified by:
        getTransactionId in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The transactionId.

      • getTransactionIdBytes

        public com.google.protobuf.ByteString getTransactionIdBytes()
         Assigned by the server. Useful for correlating logs.
 Must be a valid LedgerString (as described in ``value.proto``).
 Required
        string transaction_id = 1 [json_name = "transactionId"];
        Specified by:
        getTransactionIdBytes in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The bytes for transactionId.

      • setTransactionId

        public TransactionOuterClass.TransactionTree.Builder setTransactionId​(java.lang.String value)
         Assigned by the server. Useful for correlating logs.
 Must be a valid LedgerString (as described in ``value.proto``).
 Required
        string transaction_id = 1 [json_name = "transactionId"];
        Parameters:
        value - The transactionId to set.
        Returns:
        This builder for chaining.

      • clearTransactionId

        public TransactionOuterClass.TransactionTree.Builder clearTransactionId()
         Assigned by the server. Useful for correlating logs.
 Must be a valid LedgerString (as described in ``value.proto``).
 Required
        string transaction_id = 1 [json_name = "transactionId"];
        Returns:
        This builder for chaining.

      • setTransactionIdBytes

        public TransactionOuterClass.TransactionTree.Builder setTransactionIdBytes​(com.google.protobuf.ByteString value)
         Assigned by the server. Useful for correlating logs.
 Must be a valid LedgerString (as described in ``value.proto``).
 Required
        string transaction_id = 1 [json_name = "transactionId"];
        Parameters:
        value - The bytes for transactionId to set.
        Returns:
        This builder for chaining.

      • getCommandId

        public java.lang.String getCommandId()
         The ID of the command which resulted in this transaction. Missing for everyone except the submitting party.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string command_id = 2 [json_name = "commandId"];
        Specified by:
        getCommandId in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The commandId.

      • getCommandIdBytes

        public com.google.protobuf.ByteString getCommandIdBytes()
         The ID of the command which resulted in this transaction. Missing for everyone except the submitting party.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string command_id = 2 [json_name = "commandId"];
        Specified by:
        getCommandIdBytes in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The bytes for commandId.

      • setCommandId

        public TransactionOuterClass.TransactionTree.Builder setCommandId​(java.lang.String value)
         The ID of the command which resulted in this transaction. Missing for everyone except the submitting party.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string command_id = 2 [json_name = "commandId"];
        Parameters:
        value - The commandId to set.
        Returns:
        This builder for chaining.

      • clearCommandId

        public TransactionOuterClass.TransactionTree.Builder clearCommandId()
         The ID of the command which resulted in this transaction. Missing for everyone except the submitting party.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string command_id = 2 [json_name = "commandId"];
        Returns:
        This builder for chaining.

      • setCommandIdBytes

        public TransactionOuterClass.TransactionTree.Builder setCommandIdBytes​(com.google.protobuf.ByteString value)
         The ID of the command which resulted in this transaction. Missing for everyone except the submitting party.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string command_id = 2 [json_name = "commandId"];
        Parameters:
        value - The bytes for commandId to set.
        Returns:
        This builder for chaining.

      • getWorkflowId

        public java.lang.String getWorkflowId()
         The workflow ID used in command submission. Only set if the ``workflow_id`` for the command was set.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string workflow_id = 3 [json_name = "workflowId"];
        Specified by:
        getWorkflowId in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The workflowId.

      • getWorkflowIdBytes

        public com.google.protobuf.ByteString getWorkflowIdBytes()
         The workflow ID used in command submission. Only set if the ``workflow_id`` for the command was set.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string workflow_id = 3 [json_name = "workflowId"];
        Specified by:
        getWorkflowIdBytes in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The bytes for workflowId.

      • setWorkflowId

        public TransactionOuterClass.TransactionTree.Builder setWorkflowId​(java.lang.String value)
         The workflow ID used in command submission. Only set if the ``workflow_id`` for the command was set.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string workflow_id = 3 [json_name = "workflowId"];
        Parameters:
        value - The workflowId to set.
        Returns:
        This builder for chaining.

      • clearWorkflowId

        public TransactionOuterClass.TransactionTree.Builder clearWorkflowId()
         The workflow ID used in command submission. Only set if the ``workflow_id`` for the command was set.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string workflow_id = 3 [json_name = "workflowId"];
        Returns:
        This builder for chaining.

      • setWorkflowIdBytes

        public TransactionOuterClass.TransactionTree.Builder setWorkflowIdBytes​(com.google.protobuf.ByteString value)
         The workflow ID used in command submission. Only set if the ``workflow_id`` for the command was set.
 Must be a valid LedgerString (as described in ``value.proto``).
 Optional
        string workflow_id = 3 [json_name = "workflowId"];
        Parameters:
        value - The bytes for workflowId to set.
        Returns:
        This builder for chaining.

      • setEffectiveAt

        public TransactionOuterClass.TransactionTree.Builder setEffectiveAt​(com.google.protobuf.Timestamp value)
         Ledger effective time.
 Required
        .google.protobuf.Timestamp effective_at = 4 [json_name = "effectiveAt"];

      • setEffectiveAt

        public TransactionOuterClass.TransactionTree.Builder setEffectiveAt​(com.google.protobuf.Timestamp.Builder builderForValue)
         Ledger effective time.
 Required
        .google.protobuf.Timestamp effective_at = 4 [json_name = "effectiveAt"];

      • mergeEffectiveAt

        public TransactionOuterClass.TransactionTree.Builder mergeEffectiveAt​(com.google.protobuf.Timestamp value)
         Ledger effective time.
 Required
        .google.protobuf.Timestamp effective_at = 4 [json_name = "effectiveAt"];

      • getEffectiveAtBuilder

        public com.google.protobuf.Timestamp.Builder getEffectiveAtBuilder()
         Ledger effective time.
 Required
        .google.protobuf.Timestamp effective_at = 4 [json_name = "effectiveAt"];

      • getOffset

        public java.lang.String getOffset()
         The absolute offset. The format of this field is described in ``ledger_offset.proto``.
 Required
        string offset = 6 [json_name = "offset"];
        Specified by:
        getOffset in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The offset.

      • getOffsetBytes

        public com.google.protobuf.ByteString getOffsetBytes()
         The absolute offset. The format of this field is described in ``ledger_offset.proto``.
 Required
        string offset = 6 [json_name = "offset"];
        Specified by:
        getOffsetBytes in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The bytes for offset.

      • setOffset

        public TransactionOuterClass.TransactionTree.Builder setOffset​(java.lang.String value)
         The absolute offset. The format of this field is described in ``ledger_offset.proto``.
 Required
        string offset = 6 [json_name = "offset"];
        Parameters:
        value - The offset to set.
        Returns:
        This builder for chaining.

      • clearOffset

        public TransactionOuterClass.TransactionTree.Builder clearOffset()
         The absolute offset. The format of this field is described in ``ledger_offset.proto``.
 Required
        string offset = 6 [json_name = "offset"];
        Returns:
        This builder for chaining.

      • setOffsetBytes

        public TransactionOuterClass.TransactionTree.Builder setOffsetBytes​(com.google.protobuf.ByteString value)
         The absolute offset. The format of this field is described in ``ledger_offset.proto``.
 Required
        string offset = 6 [json_name = "offset"];
        Parameters:
        value - The bytes for offset to set.
        Returns:
        This builder for chaining.

      • containsEventsById

        public boolean containsEventsById​(java.lang.String key)
         Changes to the ledger that were caused by this transaction. Nodes of the transaction tree.
 Each key be a valid LedgerString (as describe in ``value.proto``).
 Required
        map<string, .com.daml.ledger.api.v1.TreeEvent> events_by_id = 7 [json_name = "eventsById"];
        Specified by:
        containsEventsById in interface TransactionOuterClass.TransactionTreeOrBuilder

      • getEventsByIdMap

        public java.util.Map<java.lang.String,​TransactionOuterClass.TreeEvent> getEventsByIdMap()
         Changes to the ledger that were caused by this transaction. Nodes of the transaction tree.
 Each key be a valid LedgerString (as describe in ``value.proto``).
 Required
        map<string, .com.daml.ledger.api.v1.TreeEvent> events_by_id = 7 [json_name = "eventsById"];
        Specified by:
        getEventsByIdMap in interface TransactionOuterClass.TransactionTreeOrBuilder

      • removeEventsById

        public TransactionOuterClass.TransactionTree.Builder removeEventsById​(java.lang.String key)
         Changes to the ledger that were caused by this transaction. Nodes of the transaction tree.
 Each key be a valid LedgerString (as describe in ``value.proto``).
 Required
        map<string, .com.daml.ledger.api.v1.TreeEvent> events_by_id = 7 [json_name = "eventsById"];

      • getMutableEventsById

        @Deprecated
public java.util.Map<java.lang.String,​TransactionOuterClass.TreeEvent> getMutableEventsById()
        Deprecated.
        Use alternate mutation accessors instead.

      • putEventsById

        public TransactionOuterClass.TransactionTree.Builder putEventsById​(java.lang.String key,
                                                                   TransactionOuterClass.TreeEvent value)
         Changes to the ledger that were caused by this transaction. Nodes of the transaction tree.
 Each key be a valid LedgerString (as describe in ``value.proto``).
 Required
        map<string, .com.daml.ledger.api.v1.TreeEvent> events_by_id = 7 [json_name = "eventsById"];

      • putAllEventsById

        public TransactionOuterClass.TransactionTree.Builder putAllEventsById​(java.util.Map<java.lang.String,​TransactionOuterClass.TreeEvent> values)
         Changes to the ledger that were caused by this transaction. Nodes of the transaction tree.
 Each key be a valid LedgerString (as describe in ``value.proto``).
 Required
        map<string, .com.daml.ledger.api.v1.TreeEvent> events_by_id = 7 [json_name = "eventsById"];

      • getRootEventIdsList

        public com.google.protobuf.ProtocolStringList getRootEventIdsList()
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Specified by:
        getRootEventIdsList in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        A list containing the rootEventIds.

      • getRootEventIdsCount

        public int getRootEventIdsCount()
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Specified by:
        getRootEventIdsCount in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The count of rootEventIds.

      • getRootEventIds

        public java.lang.String getRootEventIds​(int index)
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Specified by:
        getRootEventIds in interface TransactionOuterClass.TransactionTreeOrBuilder
        Parameters:
        index - The index of the element to return.
        Returns:
        The rootEventIds at the given index.

      • getRootEventIdsBytes

        public com.google.protobuf.ByteString getRootEventIdsBytes​(int index)
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Specified by:
        getRootEventIdsBytes in interface TransactionOuterClass.TransactionTreeOrBuilder
        Parameters:
        index - The index of the value to return.
        Returns:
        The bytes of the rootEventIds at the given index.

      • setRootEventIds

        public TransactionOuterClass.TransactionTree.Builder setRootEventIds​(int index,
                                                                     java.lang.String value)
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Parameters:
        index - The index to set the value at.
        value - The rootEventIds to set.
        Returns:
        This builder for chaining.

      • addRootEventIds

        public TransactionOuterClass.TransactionTree.Builder addRootEventIds​(java.lang.String value)
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Parameters:
        value - The rootEventIds to add.
        Returns:
        This builder for chaining.

      • addAllRootEventIds

        public TransactionOuterClass.TransactionTree.Builder addAllRootEventIds​(java.lang.Iterable<java.lang.String> values)
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Parameters:
        values - The rootEventIds to add.
        Returns:
        This builder for chaining.

      • clearRootEventIds

        public TransactionOuterClass.TransactionTree.Builder clearRootEventIds()
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Returns:
        This builder for chaining.

      • addRootEventIdsBytes

        public TransactionOuterClass.TransactionTree.Builder addRootEventIdsBytes​(com.google.protobuf.ByteString value)
         Roots of the transaction tree.
 Each element must be a valid LedgerString (as describe in ``value.proto``).
 The elements are in the same order as the commands in the
 corresponding Commands object that triggered this transaction.
 Required
        repeated string root_event_ids = 8 [json_name = "rootEventIds"];
        Parameters:
        value - The bytes of the rootEventIds to add.
        Returns:
        This builder for chaining.

      • hasTraceContext

        public boolean hasTraceContext()
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];
        Specified by:
        hasTraceContext in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        Whether the traceContext field is set.

      • getTraceContext

        public TraceContextOuterClass.TraceContext getTraceContext()
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];
        Specified by:
        getTraceContext in interface TransactionOuterClass.TransactionTreeOrBuilder
        Returns:
        The traceContext.

      • setTraceContext

        public TransactionOuterClass.TransactionTree.Builder setTraceContext​(TraceContextOuterClass.TraceContext value)
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];

      • setTraceContext

        public TransactionOuterClass.TransactionTree.Builder setTraceContext​(TraceContextOuterClass.TraceContext.Builder builderForValue)
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];

      • mergeTraceContext

        public TransactionOuterClass.TransactionTree.Builder mergeTraceContext​(TraceContextOuterClass.TraceContext value)
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];

      • clearTraceContext

        public TransactionOuterClass.TransactionTree.Builder clearTraceContext()
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];

      • getTraceContextBuilder

        public TraceContextOuterClass.TraceContext.Builder getTraceContextBuilder()
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];

      • getTraceContextOrBuilder

        public TraceContextOuterClass.TraceContextOrBuilder getTraceContextOrBuilder()
         Optional; ledger api trace context

 The trace context transported in this message corresponds to the trace context supplied
 by the client application in a HTTP2 header of the original command submission.
 We typically use a header to transfer this type of information. Here we use message
 body, because it is used in gRPC streams which do not support per message headers.
 This field will be populated with the trace context contained in the original submission.
 If that was not provided, a unique ledger-api-server generated trace context will be used
 instead.
        .com.daml.ledger.api.v1.TraceContext trace_context = 9 [json_name = "traceContext"];
        Specified by:
        getTraceContextOrBuilder in interface TransactionOuterClass.TransactionTreeOrBuilder