Gets the value of the transactionType property.

@return value of the transactionType property.
549482
public PersistenceUnitTransactionType getTransactionType() {
          // Convert this TransactionType from the class defined in JAXB
          // (com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType) to JPA
          // (javax.persistence.spi.PersistenceUnitTransactionType).

          PersistenceUnitTransactionType rtnType = null;
          com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType jaxbType = null;

          jaxbType = ivPUnit.getTransactionType();
          if (jaxbType == com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType.JTA) {
               rtnType = PersistenceUnitTransactionType.JTA;
          } else if (jaxbType == com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType.RESOURCE_LOCAL) {
               rtnType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
          }
          return rtnType;
     }
1117754
private TransactionalType getTransactionalType(FQMethod method) {
        TransactionalType type = transactionalMethods.get(method);
        if (type == null) {
            return TransactionalType.NONE;
        }

        return type;
    }
492775
public static Transaction convertEtherTxToKunderaTx(TransactionResult transactionResult)
    {

        Transaction kunderaTx = new Transaction();
        TransactionObject txObj = (TransactionObject) transactionResult;

        kunderaTx.setBlockHash(txObj.getBlockHash());
        kunderaTx.setBlockNumber(txObj.getBlockNumberRaw());
        kunderaTx.setCreates(txObj.getCreates());
        kunderaTx.setFrom(txObj.getFrom());
        kunderaTx.setGas(txObj.getGasRaw());
        kunderaTx.setGasPrice(txObj.getGasPriceRaw());
        kunderaTx.setHash(txObj.getHash());
        kunderaTx.setInput(txObj.getInput());
        kunderaTx.setNonce(txObj.getNonceRaw());
        kunderaTx.setPublicKey(txObj.getPublicKey());
        kunderaTx.setR(txObj.getR());
        kunderaTx.setRaw(txObj.getRaw());
        kunderaTx.setS(txObj.getS());
        kunderaTx.setTo(txObj.getTo());
        kunderaTx.setTransactionIndex(txObj.getTransactionIndexRaw());
        kunderaTx.setV(txObj.getV());
        kunderaTx.setValue(txObj.getValueRaw());

        return kunderaTx;

    }
835644
public final Transaction getTransaction()
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass
                        , "getTransaction"
                            );
        // If the log is full introduce a delay for a checkpoiunt before allowing the 
        // application to proceed.
        objectManagerState.transactionPacing();
        Transaction transaction = objectManagerState.getTransaction();

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass
                       , "getTransaction"
                       , "returns transaction=" + transaction + "(Transaction)"
                            );
        return transaction;
    }
541834
public Object getRealValue()
    {
        if(valueRealSubject != null)
        {
            return valueRealSubject;
        }
        else
        {
            TransactionExt tx = getTransaction();

            if((tx != null) && tx.isOpen())
            {
                prepareValueRealSubject(tx.getBroker());
            }
            else
            {
                if(getPBKey() != null)
                {
                    PBCapsule capsule = new PBCapsule(getPBKey(), null);

                    try
                    {
                        prepareValueRealSubject(capsule.getBroker());
                    }
                    finally
                    {
                        capsule.destroy();
                    }
                }
                else
                {
                    getLog().warn("No tx, no PBKey - can't materialise value with Identity " + getKeyOid());
                }
            }
        }
        return valueRealSubject;
    }
1308404
public long size(Transaction transaction)
                    throws ObjectManagerException
    {
        long size = 0;
        for (Iterator iterator = iterator(); iterator.hasNext(transaction); iterator.next(transaction)) {
            size++;
            if (size == Long.MAX_VALUE)
                break;
        } // for...
        return size;
    }
806239
protected TransactionTypeEnum getType(byte logstate) {
		switch ( (logstate & 0x60) >> 5) {
		case 0: return TransactionTypeEnum.LOADED;
		case 1: return TransactionTypeEnum.UNLOADED;
		case 2: return TransactionTypeEnum.PURCHASE;
		case 3: return TransactionTypeEnum.REFUND;
		}
		return null;
    }
659791
public String getTransactionId()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getTransactionId");
    
    String tranID = null;
    PersistentTranId pTranID = itemStream.getTransactionId();
    
    if (pTranID != null)
    {
      tranID = pTranID.toTMString(); 
    }
      
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getTransactionId", tranID);
    return tranID;
  }
702260
public T getValue ()
    {
        // if the value is still around and it's expired, clear it
        if (_value != null && System.currentTimeMillis() >= _expires) {
            _value = null;
        }
        // then return the value (which may be cleared to null by now)
        return _value;
    }
1098780
@Override
    public synchronized Object getValue() {
        if (id != null) {
            if (serializedValue != null) {
                long oldSize = -1;
                if (cacheEntryPool != null) {
                    if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                        oldSize = getObjectSize();
                    }
                }

                try {
                    value = SerializationUtility.deserialize(serializedValue, cacheName);
                } catch (Exception ex) {
                    com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.CacheEntry.getValue", "200", this);
                }
                if (value != null) {
                    serializedValue = null;
                    if (cacheEntryPool != null) {
                        if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                            long newSize = getObjectSize();
                            if (oldSize != -1 && newSize != -1) {
                                cacheEntryPool.cache.increaseCacheSizeInBytes(newSize - oldSize, "GET_VALUE");
                            } else {
                                cacheEntryPool.cache.disableCacheSizeInMB();
                            }
                        }
                    }
                }
            }
        }
        return value;
    }
939887
public int getJcrType( PropertyType propertyType ) {
        switch (propertyType) {
            case BOOLEAN:
                return javax.jcr.PropertyType.BOOLEAN;
            case DATETIME:
                return javax.jcr.PropertyType.DATE;
            case DECIMAL:
                return javax.jcr.PropertyType.DECIMAL;
            case HTML:
                return javax.jcr.PropertyType.STRING;
            case INTEGER:
                return javax.jcr.PropertyType.LONG;
            case URI:
                return javax.jcr.PropertyType.URI;
            case ID:
                return javax.jcr.PropertyType.STRING;
            default:
                return javax.jcr.PropertyType.UNDEFINED;
        }
    }
735273
public Transactions getTransactions(final TransactionState state, final TransactionType type, final QueryParams params) {
        if (state != null) params.put("state", state.getType());
        if (type != null) params.put("type", type.getType());

        return doGET(Transactions.TRANSACTIONS_RESOURCE, Transactions.class, params);
    }
1340293
@Nullable
    public TransactionOutput getConnectedOutput() {
        if (fromTx != null) {
            return fromTx.getOutputs().get((int) index);
        } else if (connectedOutput != null) {
            return connectedOutput;
        }
        return null;
    }
187583
protected SITransaction getTransaction() throws ResourceException {

        final String methodName = "getTransaction";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        if (_transaction == null) {

            try {

                _transaction = _connection.createUncoordinatedTransaction(false);

            } catch (final Exception exception) {

                FFDCFilter.processException(exception, CLASS_NAME + "."
                        + methodName, FFDC_PROBE_1, this);
                if (TRACE.isEventEnabled()) {
                    SibTr.exception(this, TRACE, exception);
                }
                throw new ResourceException(NLS.getFormattedMessage(
                        "UNCOORD_TRAN_CWSIV1201", new Object[] { _connection,
                                exception }, null), exception);

            }
        }

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, _transaction);
        }
        return _transaction;

    }
397505
public static String getShipType(BigInteger ts) {
        if (ts == null)
            return null;
        else
            return getShipType(ts.intValue());
    }
106962
protected Object getValue() {
        Object value = this.value;
        if (value == null) {
            this.value = value = fromBinary("value");
        }
        return value;
    }
182285
def transaction_type(self, value):
        """"""
        if value is not None:
            if value not in self.ALLOWED_TRANSACTION_TYPES:
                raise AttributeError('%s transaction_type element must be one of %s not %s' % (
                    self.__class__.__name__, ','.join(self.ALLOWED_TRANSACTION_TYPES), value,))
        self._transaction_type = value