Java Pair类代码示例

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
private Pair<ChargebackStatus, Transfer> preprocessChargeback(final Transfer transfer) {
    ChargebackStatus status = null;
    Transfer chargebackTransfer = null;

    // Check if the transfer can be charged back
    if (!paymentServiceLocal.canChargeback(transfer, false)) {
        if (transfer.getChargedBackBy() != null) {
            chargebackTransfer = transfer.getChargedBackBy();
            status = ChargebackStatus.TRANSFER_ALREADY_CHARGEDBACK;
        } else {
            if (transfer.getStatus() == Payment.Status.PENDING) {
                final TransferAuthorizationDTO transferAuthorizationDto = new TransferAuthorizationDTO();
                transferAuthorizationDto.setTransfer(transfer);
                transferAuthorizationDto.setShowToMember(false);
                chargebackTransfer = transferAuthorizationServiceLocal.cancel(transferAuthorizationDto);
                status = ChargebackStatus.SUCCESS;
            } else {
                status = ChargebackStatus.TRANSFER_CANNOT_BE_CHARGEDBACK;
            }
        }
    }

    return new Pair<ChargebackStatus, Transfer>(status, chargebackTransfer);
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
/**
 * Stop using the specified object.
 */
private void release(final Pair<Object, Object> pair) {
    try {
        // Release from the thread local
        Set<Pair<Object, Object>> acquiredKeys = ACQUIRED.get();
        if (acquiredKeys != null) {
            acquiredKeys.remove(pair);
            if (acquiredKeys.isEmpty()) {
                ACQUIRED.remove();
            }
        }
    } finally {
        // Remove from the shared set
        getLocks().remove(pair);
    }
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
public List<Pair<Member, BigDecimal>> getGrossProductPerMember(final StatisticalDTO dto) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final StringBuilder hql = new StringBuilder("select new " + Pair.class.getName());
    hql.append("(m, sum(t.amount)) from Transfer t, Member m where 1=1 ");
    hql.append(" and t.chargedBackBy is null and t.chargebackOf is null ");
    hql.append(" and exists (select ma.id from MemberAccount ma where t.to = ma and m = ma.member) ");
    appendGroupAndPaymentFilterAndPeriod(hql, namedParameters, dto);
    // Group by the member that received the transfer
    hql.append(" group by m ");

    // Order by the sum of amounts
    hql.append(" order by sum(t.amount) desc ");

    return list(hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
public List<Pair<Member, Integer>> getNumberOfTransactionsPerMember(final StatisticalDTO dto) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final StringBuilder hql = new StringBuilder();
    hql.append("select new " + Pair.class.getName() + "(m, count(t.id))");
    hql.append(" from Transfer t, Member m where 1=1 ");
    hql.append(" and t.chargedBackBy is null and t.chargebackOf is null ");
    // transaction to
    hql.append(" and (exists (select ma.id from MemberAccount ma where t.to = ma and m = ma.member) ");
    // transaction from (added by Rinke, because eventually this seemed more logical)
    hql.append(" or exists (select ma.id from MemberAccount ma where t.from = ma and m = ma.member)) ");
    appendGroupAndPaymentFilterAndPeriod(hql, namedParameters, dto);

    // Group by the member that received the transfer
    hql.append(" group by m ");

    // Order by the sum of amounts
    hql.append(" order by count(t.id) desc ");

    return list(hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
public BigDecimal getSumOfTransactions(final StatisticalDTO dto) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    // the query uses the same as getGrossProductPerMember, because mysql appears to be much faster with this query than with a simple select
    // sum(t.amount) without "group by".
    final StringBuilder hql = new StringBuilder("select new " + Pair.class.getName());
    hql.append("(m, sum(t.amount)) from Transfer t, Member m where 1=1 ");
    hql.append(" and t.chargedBackBy is null and t.chargebackOf is null ");
    hql.append(" and exists (select ma.id from MemberAccount ma where t.to = ma and m = ma.member) ");
    appendGroupAndPaymentFilterAndPeriod(hql, namedParameters, dto);
    // TransferType
    if (dto.getTransferType() != null) {
        hql.append(" and t.type = :transferType ");
        namedParameters.put("transferType", dto.getTransferType());
    }
    hql.append(" group by m ");

    final List<Pair<Member, BigDecimal>> sums = list(hql.toString(), namedParameters);
    BigDecimal sumOfTransactions = BigDecimal.ZERO;
    for (final Pair<Member, BigDecimal> item : sums) {
        sumOfTransactions = sumOfTransactions.add(item.getSecond());
    }
    return sumOfTransactions;
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
private AccountFee getVolumeFee(final AccountType accountType, final MemberGroup group) {
    Pair<Long, Long> key = new Pair<Long, Long>(accountType.getId(), group.getId());
    return getVolumeFeeByAccountCache().get(key, new CacheCallback() {
        @Override
        public Object retrieve() {
            final AccountFeeQuery query = new AccountFeeQuery();
            query.setAccountType(accountType);
            query.setGroups(Collections.singleton(group));
            query.setType(RunMode.SCHEDULED);
            List<AccountFee> fees = search(query);
            for (Iterator<AccountFee> iterator = fees.iterator(); iterator.hasNext();) {
                if (!iterator.next().getChargeMode().isVolume()) {
                    iterator.remove();
                }
            }
            if (fees.size() > 1) {
                throw new ValidationException("accountFee.error.multipleVolumeFees");
            }
            return fees.isEmpty() ? null : fees.iterator().next();
        }
    });
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
protected List<?> executeQuery(final ActionContext context) {
    final MembersReportHandler reportHandler = getReportHandler();
    final Pair<MembersTransactionsReportDTO, Iterator<MemberTransactionSummaryReportData>> pair = reportHandler.handleTransactionsSummary(context);
    final MembersTransactionsReportDTO dto = pair.getFirst();
    final Iterator<MemberTransactionSummaryReportData> reportIterator = pair.getSecond();
    final Iterator iterator = IteratorUtils.filteredIterator(reportIterator, new Predicate() {
        @Override
        public boolean evaluate(final Object element) {
            final MemberTransactionSummaryReportData data = (MemberTransactionSummaryReportData) element;
            if (dto.isIncludeNoTraders()) {
                return true;
            }
            return data.isHasData();
        }
    });
    return new IteratorListImpl(iterator);
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
protected List<?> executeQuery(final ActionContext context) {
    final MembersReportHandler reportHandler = getReportHandler();
    final Pair<MembersTransactionsReportDTO, Iterator<MemberTransactionDetailsReportData>> pair = reportHandler.handleTransactionsDetails(context);
    final MembersTransactionsReportDTO dto = pair.getFirst();
    final Iterator<MemberTransactionDetailsReportData> reportIterator = pair.getSecond();
    final Iterator iterator = IteratorUtils.filteredIterator(reportIterator, new Predicate() {
        @Override
        public boolean evaluate(final Object element) {
            final MemberTransactionDetailsReportData data = (MemberTransactionDetailsReportData) element;
            if (dto.isIncludeNoTraders()) {
                return true;
            }
            return data.getAmount() != null;
        }
    });
    return new IteratorListImpl(iterator);
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
private ChargebackResult doChargeback(final Transfer transfer) {

        final Pair<ChargebackStatus, Transfer> preprocessResult = preprocessChargeback(transfer);
        ChargebackStatus status = preprocessResult.getFirst();
        Transfer chargebackTransfer = preprocessResult.getSecond();

        // Do the chargeback
        if (status == null) {
            chargebackTransfer = paymentServiceLocal.chargeback(transfer);
            status = ChargebackStatus.SUCCESS;
        }

        if (!status.isSuccessful()) {
            webServiceHelper.error("Chargeback result: " + status);
        }

        Member member = WebServiceContext.getMember();
        // Build the result
        if (status == ChargebackStatus.SUCCESS || status == ChargebackStatus.TRANSFER_ALREADY_CHARGEDBACK) {
            AccountHistoryTransferVO originalVO = null;
            AccountHistoryTransferVO chargebackVO = null;
            try {
                final AccountOwner owner = member == null ? transfer.getToOwner() : member;
                originalVO = accountHelper.toVO(owner, transfer, null);
                chargebackVO = accountHelper.toVO(owner, chargebackTransfer, null);
            } catch (Exception e) {
                webServiceHelper.error(e);
                if (applicationServiceLocal.getLockedAccountsOnPayments() == LockedAccountsOnPayments.NONE) {
                    // The chargeback is committed on the same transaction so it will be rolled back by this exception, then status is given by this
                    // exception.
                    status = ChargebackStatus.TRANSFER_CANNOT_BE_CHARGEDBACK;
                }
                // When the locking method is not NONE, the chargeback is committed on a new transaction so we'll preserve the status.
            }
            return new ChargebackResult(status, originalVO, chargebackVO);
        } else {
            return new ChargebackResult(status, null, null);
        }
    }
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
/**
 * Returns the {@link ServerErrorVO} bean and the status code representing the given exception
 */
public static Pair<ServerErrorVO, Integer> resolveError(final Throwable t) {
    if (t instanceof EntityNotFoundException) {
        return Pair.of(handleEntityNotFound((EntityNotFoundException) t), HttpServletResponse.SC_NOT_FOUND);
    } else if (t instanceof IllegalArgumentException) {
        return Pair.of(handleIllegalArgumentException((IllegalArgumentException) t), HttpServletResponse.SC_BAD_REQUEST);
    } else if (t instanceof ValidationException) {
        return Pair.of(handleValidationException((ValidationException) t), HttpServletResponse.SC_BAD_REQUEST);
    } else if (t instanceof PermissionDeniedException) {
        return Pair.of(handlePermissionDenied(), HttpServletResponse.SC_FORBIDDEN);
    } else {
        return Pair.of(handleUnknownException(), HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    }
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
/**
 * Handles {@link Exception}s
 */
@ExceptionHandler(Exception.class)
@ResponseBody
public ServerErrorVO handleUnknownException(final Exception ex, final HttpServletResponse response) throws IOException {
    Pair<ServerErrorVO, Integer> error = RestHelper.resolveError(ex);
    int errorCode = error.getSecond();
    if (errorCode == HttpServletResponse.SC_INTERNAL_SERVER_ERROR) {
        LOG.error("Error on REST call", ex);
    }
    response.setStatus(errorCode);
    return error.getFirst();
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
public boolean tryAcquire(final Pair<Object, Object> pair) {
    // If this thread has the lock already, return
    Set<Pair<Object, Object>> acquiredKeys = ACQUIRED.get();
    if (acquiredKeys != null && acquiredKeys.contains(pair)) {
        // Already acquired by this thread
        return true;
    }
    boolean acquired = getLocks().add(pair);
    if (acquired) {
        // Store on the thread local
        if (acquiredKeys == null) {
            acquiredKeys = new HashSet<Pair<Object, Object>>();
            ACQUIRED.set(acquiredKeys);
        }
        acquiredKeys.add(pair);

        // Add an end transaction listener to ensure we'll release the lock
        CurrentTransactionData.addTransactionEndListener(new TransactionEndListener() {
            @Override
            protected void onTransactionEnd(final boolean commit) {
                release(pair);
            }
        });
    }
    return acquired;
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
/**
 * takes the second elements of a <code>Collection</code> of <code>Pair</code>s, and returns them in a List
 * 
 * @param <S> the type of the frist element of the <code>Pair</code>s in the input collection
 * @param <T> the type of the second element of the <code>Pair</code>s in the input collection
 * @param collection the input <code>Collection</code> with <code>Pair</code>s
 * @return a List with only the second elements of the <code>Pair</code>s.
 */
public static <S, T> List<T> getSecondFromPairCollection(final Collection<Pair<S, T>> collection) {
    final List<T> seconds = new ArrayList<T>();
    for (final Pair<S, T> pair : collection) {
        final T t = pair.getSecond();
        seconds.add(t);
    }
    return seconds;
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
@Override
public List<Number> getTransactionAmounts(final StatisticalDTO dto) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final StringBuilder hql = new StringBuilder();
    hql.append("select new " + Pair.class.getName() + "(t.id, t.amount)");
    hql.append(" from Transfer t, Member m where 1=1 ");
    hql.append(" and t.chargedBackBy is null and t.chargebackOf is null ");
    hql.append(" and (exists (select ma.id from MemberAccount ma where t.to = ma and m = ma.member) ");
    hql.append(" or exists (select ma.id from MemberAccount ma where t.from = ma and m = ma.member)) ");
    appendGroupAndPaymentFilterAndPeriod(hql, namedParameters, dto);
    final List<Pair<Long, BigDecimal>> pairList = list(hql.toString(), namedParameters);
    // because using to and from's, duplicate id's may appear. Transferring to Set solves this.
    final Set<Pair<Long, BigDecimal>> pairSet = new HashSet<Pair<Long, BigDecimal>>(pairList);
    return ListOperations.getSecondNumberFromPairCollection(pairSet);
}
 

import nl.strohalm.cyclos.utils.Pair; //导入依赖的package包/类
/**
 * It locks the custom field value only if it's set as unique.
 * @param value
 */
protected void lockUniqueFieldValue(final CustomField field, final CustomFieldValue value) {
    if (field.getValidation().isUnique()) {
        final Pair<Object, Object> pair = Pair.<Object, Object> of(field, value.getValue());
        if (!uniqueObjectHandler.tryAcquire(pair)) {
            throw new ValidationException(new UniqueError(field.getName()));
        }
    }
}