Returns TxnId object instance for a given transaction with UUID.

@param txnId UUID
@return Instance of TxnId.
335846
public static final TxnId decode(final UUID txnId) {
        Preconditions.checkNotNull(txnId, "txnId");
        return TxnId.newBuilder()
                .setHighBits(txnId.getMostSignificantBits())
                .setLowBits(txnId.getLeastSignificantBits())
                .build();
    }
689573
def get_block_containing_tx(self, txid):
        
        blocks = list(backend.query.get_block_with_transaction(self.connection, txid))
        if len(blocks) > 1:
            logger.critical('Transaction id %s exists in multiple blocks', txid)

        return [block['height'] for block in blocks]
655289
public static Consortium get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, Consortium> cache = InfinispanCache.get().<UUID, Consortium>getCache(Consortium.IDCACHE);
        if (!cache.containsKey(_uuid)) {
            Consortium.getConsortiumFromDB(Consortium.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
187130
def get_by_id(self, tx_id: str) -> ScheduledTransaction:
        
        return self.query.filter(ScheduledTransaction.guid == tx_id).first()
1075523
def _get(self, tx_id):
        
        # tx_id=self._find_tx_id(resource_id)
        value = [
            {
                'data': transaction['metadata'],
                'id': transaction['id']
            }
            for transaction in self.driver.instance.transactions.get(asset_id=self.get_asset_id(tx_id))
        ][-1]
        if value['data']['data']:
            self.logger.debug('bdb::read::{}'.format(value['data']))
            return value
        else:
            return False
326179
protected static long getId4UUID(final UUID _typeUUID)
        throws CacheReloadException
    {
        long ret = 0;
        final Cache<UUID, Type> cache = InfinispanCache.get().<UUID, Type>getCache(Type.UUIDCACHE);
        if (cache.containsKey(_typeUUID)) {
            ret = cache.get(_typeUUID).getId();
        } else {
            Connection con = null;
            try {
                con = Context.getConnection();
                PreparedStatement stmt = null;
                try {
                    stmt = con.prepareStatement(Type.SQL_UUID);
                    stmt.setObject(1, _typeUUID.toString());
                    final ResultSet rs = stmt.executeQuery();
                    while (rs.next()) {
                        ret = rs.getLong(1);
                    }
                    rs.close();
                } finally {
                    if (stmt != null) {
                        stmt.close();
                    }
                }
                con.commit();
            } catch (final SQLException e) {
                throw new CacheReloadException("could not read child type ids", e);
            } catch (final EFapsException e) {
                throw new CacheReloadException("could not read child type ids", e);
            } finally {
                try {
                    if (con != null && !con.isClosed()) {
                        con.close();
                    }
                } catch (final SQLException e) {
                    throw new CacheReloadException("could not read child type ids", e);
                }
            }
        }
        return ret;
    }
585420
private synchronized Identity getNodeFromCache(final String uuid) {

		if (nodeUuidMap == null) {

			nodeUuidMap = new FixedSizeCache<>(Settings.UuidCacheSize.getValue());
		}

		return nodeUuidMap.get(uuid);
	}
1150332
public Optional<KeyTransaction> show(long transactionId)
    {
        return HTTP.GET(String.format("/v2/key_transactions/%d.json", transactionId), KEY_TRANSACTION);
    }
210856
public Transaction getTransaction(final String transactionId) {
        if (transactionId == null || transactionId.isEmpty())
            throw new RuntimeException("transactionId cannot be empty!");

        return doGET(Transactions.TRANSACTIONS_RESOURCE + "/" + transactionId,
                     Transaction.class);
    }
1099855
public Uid setUid(String uid) {
		Uid property = (uid == null) ? null : new Uid(uid);
		setUid(property);
		return property;
	}
1320674
@Override
	public byte[] getTransIdByte(TransactionId transId) {

		int appIdCode = codecer.findId(APP_ID, transId.getAppId()).intValue();
		int busCodeId = codecer.findId(BUSINESS_CODE, transId.getBusCode()).intValue();

		ByteBuffer byteBuffer = ByteBuffer.allocate(12);
		putUnsignedShort(byteBuffer, appIdCode);
		putUnsignedShort(byteBuffer, busCodeId);
		byteBuffer.putLong(transId.getTrxId());
		
		return byteBuffer.array();
	}
1294441
public CreateTransactionResult createTransaction(
            final long connectionId,
            final long txnId,
            final long uniqueId,
            final StoredProcedureInvocation invocation,
            final boolean isReadOnly,
            final boolean isSinglePartition,
            final boolean isEveryPartition,
            final int partition,
            final int messageSize,
            long nowNanos,
            final boolean isForReplay)
    {
        return m_dispatcher.createTransaction(
                connectionId,
                txnId,
                uniqueId,
                invocation,
                isReadOnly,
                isSinglePartition,
                isEveryPartition,
                new int [] { partition },
                messageSize,
                nowNanos,
                isForReplay);
    }
1069248
@Programmatic
    public List<PublishedEvent> findByTransactionId(final UUID transactionId) {
        return repositoryService.allMatches(
                new QueryDefault<>(PublishedEvent.class,
                        "findByTransactionId", 
                        "transactionId", transactionId));
    }
1281804
@Basic
    @Column(name = "UIDENT", unique = true, nullable = false, length=255)
    public String getUid()
    {
        return this.uid;
    }
1243135
public function get($transactionId)
    {
        if ($transactionId <= 0) {
            throw new HpsArgumentException('Invalid Transaction Id',HpsExceptionCodes::INVALID_ORIGINAL_TRANSACTION);
        }

        $xml = new DOMDocument();
        $hpsTransaction = $xml->createElement('hps:Transaction');
        $hpsReportTxnDetail = $xml->createElement('hps:ReportTxnDetail');
        $hpsReportTxnDetail->appendChild($xml->createElement('hps:TxnId', $transactionId));
        $hpsTransaction->appendChild($hpsReportTxnDetail);

        return $this->_submitTransaction($hpsTransaction, 'ReportTxnDetail');
    }
564196
public static function get($transactionId)
    {
        $api = new Api\Info();
        $api->setTransactionId($transactionId);
        $result = $api->doRequest();

        $result['transactionId'] = $transactionId;

        return new Result\Transaction($result);
    }
1197002
public String getTransactionId() throws SIMPException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getTransactionId");

    assertValidControllable();

    String id = null;
    PersistentTranId pTranId = msgItem.getTransactionId();
    if (pTranId != null)
    {
      id = pTranId.toTMString();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getTransactionId", id);
    return id;
  }