Get the value of the transaction time.
@return The value of the transaction time. (NullAllowed)
543047
public static Date getTransactionTime() {
        final Stack<Date> stack = threadLocal.get();
        return stack != null ? stack.peek() : null;
    }
103128
@Override
	public Long getValue() {
		final JobStatus status = eg.getState();

		if (status == JobStatus.RUNNING) {
			// running right now - report the uptime
			final long runningTimestamp = eg.getStatusTimestamp(JobStatus.RUNNING);
			// we use 'Math.max' here to avoid negative timestamps when clocks change
			return Math.max(System.currentTimeMillis() - runningTimestamp, 0);
		}
		else if (status.isTerminalState()) {
			// not running any more -> finished or not on leader
			return NO_LONGER_RUNNING;
		}
		else {
			// not yet running or not up at the moment
			return 0L;
		}
	}
440833
public String getTimestamp() {
        return (data != null && data.payload != null) ? data.payload.timestamp : null;
    }
278822
public Integer getSessionTimeout()
   {
      if (childNode.getTextValueForPatternName("session-timeout") != null && !childNode.getTextValueForPatternName("session-timeout").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("session-timeout"));
      }
      return null;
   }
1311241
public Integer getLoginTimeout()
   {
      if (childNode.getTextValueForPatternName("login-timeout") != null && !childNode.getTextValueForPatternName("login-timeout").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("login-timeout"));
      }
      return null;
   }
1318222
public Date getLastBackupTime() {
		long time = System.currentTimeMillis();
		String lastBackupTime = redis.getSet(KEY, Long.toString(time));
		if (lastBackupTime == null || lastBackupTime.length() == 0) {
			return null;
		}
		long backupTime = Long.parseLong(lastBackupTime);
		if (backupTime <= 0) {
			return null;
		}
		return new Date(backupTime);
	}
299246
public <V> V getValue() {
        if (values == null || values.isEmpty()) {
            return null;
        }
        return (V)values.get(0);
    }
898073
public int getTimeoutValueInSSLClosingHandshake() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "timeoutValueInSSLClosingHandshake : " + this.timeoutValueInSSLClosingHandshake);
        }
        return this.timeoutValueInSSLClosingHandshake;
    }
1054056
public String getTransaction()
   {
      if (transaction == null)
      {
         TraceEvent transactionEvent =
            TraceEventHelper.getType(events,
                                     TraceEvent.ENLIST_CONNECTION_LISTENER,
                                     TraceEvent.ENLIST_CONNECTION_LISTENER_FAILED,
                                     TraceEvent.ENLIST_INTERLEAVING_CONNECTION_LISTENER,
                                     TraceEvent.ENLIST_INTERLEAVING_CONNECTION_LISTENER_FAILED);
      
         if (transactionEvent != null)
         {
            transaction = transactionEvent.getPayload1();
         }
         else
         {
            transaction = "";
         }
      }

      if (!"".equals(transaction))
         return transaction;

      return null;
   }
1241084
@Nullable
    public Date getGpsDate()
    {
        String date = getString(TAG_DATE_STAMP);
        Rational[] timeComponents = getRationalArray(TAG_TIME_STAMP);

        // Make sure we have the required values
        if (date == null)
            return null;
        if (timeComponents == null || timeComponents.length != 3)
            return null;

        String dateTime = String.format(Locale.US, "%s %02d:%02d:%02.3f UTC",
            date, timeComponents[0].intValue(), timeComponents[1].intValue(), timeComponents[2].doubleValue());
        try {
            DateFormat parser = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss.S z");
            return parser.parse(dateTime);
        } catch (ParseException e) {
            return null;
        }
    }
403325
synchronized public long getValue() {

        if (limitReached) {
            throw Error.error(ErrorCode.X_2200H);
        }

        long nextValue;

        if (increment > 0) {
            if (currValue > maxValue - increment) {
                if (isCycle) {
                    nextValue = minValue;
                } else {
                    limitReached = true;
                    nextValue    = minValue;
                }
            } else {
                nextValue = currValue + increment;
            }
        } else {
            if (currValue < minValue - increment) {
                if (isCycle) {
                    nextValue = maxValue;
                } else {
                    limitReached = true;
                    nextValue    = minValue;
                }
            } else {
                nextValue = currValue + increment;
            }
        }

        long result = currValue;

        currValue = nextValue;

        return result;
    }
307466
private SITransaction getCurrentTransaction() {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, "getCurrentTransaction");
        }

        SITransaction currentTransaction = null;

        // Is there a current local transaction?

        if (_localTransaction != null) {

            currentTransaction = _localTransaction.getCurrentTransaction();

        }

        // If not, is there a current global transaction?

        if ((currentTransaction == null) && (_xaResource != null)) {

            currentTransaction = _xaResource.getCurrentTransaction();

        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr
                    .exit(this, TRACE, "getCurrentTransaction",
                            currentTransaction);
        }
        return currentTransaction;

    }
999380
public static java.sql.Timestamp getTimestamp(Object value) {
        try {
            return toTimestamp(value);
        } catch (ParseException pe) {
            pe.printStackTrace();
            return null;
        }
    }
279125
synchronized int getCommitType(long timestamp) {

        RowActionBase action = this;
        int           type   = ACTION_NONE;

        do {
            if (action.commitTimestamp == timestamp) {
                type = action.type;
            }

            action = action.next;
        } while (action != null);

        return type;
    }
677567
public javax.transaction.Transaction getJTATransaction()
    {
        if(tm == null)
        {
            try
            {
                tm = TransactionManagerFactoryFactory.instance().getTransactionManager();
            }
            catch (TransactionManagerFactoryException e)
            {
                throw new TransactionFactoryException("Can't instantiate TransactionManagerFactory", e);
            }
        }
        try
        {
            return tm.getTransaction();
        }
        catch(SystemException e)
        {
            throw new TransactionFactoryException("Error acquiring JTA Transaction", e);
        }
    }
578420
@Override
	public int getStatus() throws TransactionManagementException {
		logger.entering(CLASSNAME, "getStatus");
		int status = 0;
		
		try {
			status = userTran.getStatus();
			logger.log(Level.FINE, "javax.transaction.Status: {0}", status);
		} catch (SystemException e) {
			throw new TransactionManagementException(e);
		}
		logger.exiting(CLASSNAME, "getStatus", status);
		return status;
	}
527092
public Integer getMaxIdleTime()
   {
      if (childNode.getTextValueForPatternName("max-idle-time") != null && !childNode.getTextValueForPatternName("max-idle-time").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("max-idle-time"));
      }
      return null;
   }