How to use

nicePairOf

method

in

com.atlassian.jira.util.lang.Pair

public CascadingOption (Option parent, Option child)
{
  this.options = Pair.nicePairOf(parent, child);
}

public MultipleKeyRegistrant<T> implementing(final Class<? super T> interfaceClass, final ComponentContainer.Scope desiredScope)
{
  implementing.add(Pair.<Class<? super T>, ComponentContainer.Scope>nicePairOf(interfaceClass, desiredScope));
  return this;
}

@Override
public List<Pair<String, Object>> getHiddenFields()
{
  final ImmutableList.Builder<Pair<String, Object>> builder = builder();
  builder.add(Pair.<String, Object>nicePairOf(PARAM_SCHEME_NAME, getSchemeName()));
  builder.add(Pair.<String, Object>nicePairOf(PARAM_SCHEME_DESCRIPTION, getSchemeDescription()));
  builder.add(Pair.<String, Object>nicePairOf(PARAM_SCHEME_ID, getSchemeId()));
  builder.add(Pair.<String, Object>nicePairOf(PARAM_PROJECT_ID, getProjectId()));
  builder.add(Pair.<String, Object>nicePairOf(PARAM_FIELD_ID, getFieldId()));
  builder.add(Pair.<String, Object>nicePairOf(PARAM_DEFAULT_OPTION, getDefaultOption()));
  final String[] options = getSelectedOptions();
  if (options != null)
  {
    for (String s : options)
    {
      builder.add(Pair.<String, Object>nicePairOf(PARAM_SELECTED_OPTIONS, s));
    }
  }
  return builder.build();
}

private Pair<Boolean, String> canUnwatchIssue (final Issue issue, final ApplicationUser remoteUser, final ApplicationUser watcher)
    throws WatchingDisabledException
{
  try
  {
    if (!isWatchingEnabled())
    {
      throw new WatchingDisabledException();
    }
    checkModifyWatchersPermission(issue, remoteUser, watcher);
    return Pair.nicePairOf(true, null);
  }
  catch (PermissionException e)
  {
    return Pair.nicePairOf(false, buildRemoveUserNotAllowedString(issue, remoteUser));
  }
}

private Pair<String, Long> valueAndOffSet(Object fieldValue, String fieldName)
{
  String value;
  Long offset;
  if (fieldValue != null)
  {
    offset = getPeriodOffset(fieldName);
    value = formatFieldValue(fieldValue, offset);
  }
  else
  {
    value = null;
    offset = null;
  }
  return Pair.nicePairOf(value, offset);
}

private Pair<Boolean, String> canWatchIssue (final Issue issue, final ApplicationUser remoteUser, final ApplicationUser watcher)
    throws WatchingDisabledException
{
  try
  {
    if (!isWatchingEnabled())
    {
      throw new WatchingDisabledException();
    }
    final boolean canView = permissionManager.hasPermission(Permissions.BROWSE, issue, watcher);
    if (!canView)
    {
      return Pair.nicePairOf(false, buildAddWatcherCannotViewString(issue, remoteUser, watcher));
    }
    checkModifyWatchersPermission(issue, remoteUser, watcher);
    return Pair.nicePairOf(true, null);
  }
  catch (PermissionException e)
  {
    return Pair.nicePairOf(false, buildAddWatcherNotAllowedString(issue, remoteUser));
  }
}

@Override
public BulkWatchResult addWatcherToAll(final Collection<Issue> issues, final ApplicationUser remoteUser,
    final ApplicationUser watcher, final Context taskContext) throws WatchingDisabledException
{
  Collection<Issue> successfulIssues = new ArrayList<Issue> ();
  Collection<Pair<Issue,String>> failedIssues = new ArrayList<Pair<Issue,String>> ();
  for (Issue issue : issues)
  {
    Pair<Boolean, String> canWatchIssue = canWatchIssue(issue, remoteUser, watcher);
    if (canWatchIssue.first().booleanValue())
    {
      successfulIssues.add (issue);
    }
    else
    {
      failedIssues.add(Pair.nicePairOf(issue, canWatchIssue.second()));
    }
  }
  if (!successfulIssues.isEmpty())
  {
    watcherManager.startWatching(watcher, successfulIssues, taskContext);
  }
  return new BulkWatchResult(failedIssues);
}

@Override
public BulkWatchResult removeWatcherFromAll(final Collection<Issue> issues, final ApplicationUser remoteUser,
    final ApplicationUser watcher, final Context taskContext) throws WatchingDisabledException
{
  Collection<Issue> successfulIssues = new ArrayList<Issue> ();
  Collection<Pair<Issue,String>> failedIssues = new ArrayList<Pair<Issue,String>> ();
  for (Issue issue : issues)
  {
    Pair<Boolean, String> canUnwatchIssue = canUnwatchIssue(issue, remoteUser, watcher);
    if (canUnwatchIssue.first().booleanValue())
    {
      successfulIssues.add (issue);
    }
    else
    {
      failedIssues.add (Pair.nicePairOf(issue, canUnwatchIssue.second()));
    }
  }
  if (!successfulIssues.isEmpty())
  {
    watcherManager.stopWatching(watcher, successfulIssues, taskContext);
  }
  return new BulkWatchResult(failedIssues);
}

private Option<Pair<String, Object>> invoke(final Object targetObject, final Method method)
{
  try
  {
    Object value = method.invoke(targetObject);
    // JRADEV-21033 Pair.of is a strictPairOf, will throw exception if value is null.
    Pair<String, Object> pair = Pair.nicePairOf(getKey(method), value);
    return Option.some(pair);
  }
  catch (IllegalAccessException e)
  {
    return Option.none();
  }
  catch (InvocationTargetException e)
  {
    return Option.none();
  }
}

public boolean getSectionContainsAtleastOneLink(String parentSection, String section)
{
  LinkedList<Pair<String,String>> parentAndSectionList = new LinkedList<>();
  parentAndSectionList.add(Pair.nicePairOf(parentSection,section));
  while (!parentAndSectionList.isEmpty())
  {
    final Pair<String,String> currentPair = parentAndSectionList.pop();
    final List<SimpleLinkSection> sectionList = getChildSectionsForSection(currentPair.second());
    if (sectionList != null)
    {
      for (final SimpleLinkSection aSectionList : sectionList)
      {
        parentAndSectionList.addLast(Pair.of(currentPair.second(), aSectionList.getId()));
      }
    }
    final List<SimpleLink> links = getLinksForSection(currentPair.first(),currentPair.second());
    if (links != null && !links.isEmpty())
    {
      return true;
    }
  }
  return false;
}

requiredFeatureKey = Pair.nicePairOf(featureKey.getText(),featureEnabled);