For a given activity, retrieve a map of the activity code values which have been assigned to it.

@param activity target activity
@return map of activity code value UUIDs
176178
Map<UUID, UUID> getActivityCodes(Activity activity)
   {
      Map<UUID, UUID> map = m_activityCodeCache.get(activity);
      if (map == null)
      {
         map = new HashMap<UUID, UUID>();
         m_activityCodeCache.put(activity, map);
         for (CodeAssignment ca : activity.getCodeAssignment())
         {
            UUID code = getUUID(ca.getCodeUuid(), ca.getCode());
            UUID value = getUUID(ca.getValueUuid(), ca.getValue());
            map.put(code, value);
         }
      }
      return map;
   }
1369705
public Map<String, String> getGroupNameValueMap(String targetString) {
        return getMatcherAsOpt(targetString)
                .map(matcher -> groupNameList.stream()
                        .collect(Collectors
                                .toMap(Function.identity(), matcher::group)))
                .orElseGet(Collections::emptyMap);
    }
403445
private Map<UUID, DateTime> getNextTransitionsForSubscriptions(final BillingEventSet billingEvents) {

        final DateTime now = clock.getUTCNow();
        final Map<UUID, DateTime> result = new HashMap<UUID, DateTime>();
        for (final BillingEvent evt : billingEvents) {
            final UUID subscriptionId = evt.getSubscriptionId();
            final DateTime evtEffectiveDate = evt.getEffectiveDate();
            if (evtEffectiveDate.compareTo(now) <= 0) {
                continue;
            }
            final DateTime nextUpcomingPerSubscriptionDate = result.get(subscriptionId);
            if (nextUpcomingPerSubscriptionDate == null || nextUpcomingPerSubscriptionDate.compareTo(evtEffectiveDate) > 0) {
                result.put(subscriptionId, evtEffectiveDate);
            }
        }
        return result;
    }
253367
public Map<String, MBeanOperationInfo> getOperationMetadata() {

        MBeanOperationInfo[] operations = mBeanInfo.getOperations();

        Map<String, MBeanOperationInfo> operationMap = new TreeMap<String, MBeanOperationInfo>();
        for (MBeanOperationInfo operation: operations) {
            operationMap.put(operation.getName(), operation);
        }
        return operationMap;
    }
1059328
@Override
  protected String generateActivityInstanceId(String activityId) {

    if (activityId.equals(processDefinitionId)) {
      return processInstanceId;

    } else {

      String nextId = Context.getProcessEngineConfiguration().getIdGenerator().getNextId();

      String compositeId = activityId + ":" + nextId;
      if (compositeId.length() > 64) {
        return String.valueOf(nextId);
      } else {
        return compositeId;
      }
    }
  }
255202
public ActivityHandle getActivityHandle(Object arg0) {
        if (arg0 instanceof HttpClientNIORequestActivityImpl) {
            HttpClientNIORequestActivityHandle handle = new HttpClientNIORequestActivityHandle(
                    ((HttpClientNIORequestActivityImpl) arg0).getId());
            if (activities.containsKey(handle)) {
                return handle;
            }
        }
        return null;
    }
454582
private List<Transition> getIncomingTransitions(Process procdef, Long activityId,
            Map<String,String> idToEscapedName) {
        List<Transition> incomingTransitions = new ArrayList<Transition>();
        for (Transition trans : procdef.getTransitions()) {
            if (trans.getToId().equals(activityId)) {
                Transition sync = new Transition();
                sync.setId(trans.getId());
                Activity act = procdef.getActivityVO(trans.getFromId());
                String logicalId = act.getLogicalId();
                // id to escaped name map is for backward compatibility
                idToEscapedName.put(logicalId, escape(act.getName()));
                sync.setCompletionCode(logicalId);
                incomingTransitions.add(sync);
            }
        }
        return incomingTransitions;
    }
730330
public Query queryActivity() {
        Query q = queryEntitiesRequest(HttpMethod.GET, null, null,
               organizationId, applicationId, "activities");
        return q;
    }
291199
private static Map<String, Object> getAnnoAsMap(Object targetClass, String annoFullName) {
		Annotation[] anno = getAnnotations(targetClass);
		for (Annotation a : anno) {
			Class<? extends Annotation> type = a.annotationType();
			if (annoFullName.equals(type.getName()))
				return changeAnnotationValuesToMap(a);
		}
		return null;
	}
536072
public String getName(Activity activity) {
        if (nameTokens != null && nameTokens.length > 0) {
            TokenEvaluator evaluator = new TokenExpression(activity);
            return evaluator.evaluateAsString(nameTokens);
        } else {
            return name;
        }
    }
999171
@Override
    public SIBUuid12 getBaseUuid()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getBaseUuid");

        SIBUuid12 uuid = _targetDestinationHandler.getDefinition().getUUID();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getBaseUuid", uuid);

        return uuid;
    }
402632
public static Map<String, Object> getInputOutputMap(Message message, KnowledgeOperation operation, KnowledgeRuntimeEngine runtime) {
        Map<String, Object> map = new LinkedHashMap<String, Object>();
        Map<String, ExpressionMapping> inputs = operation.getInputOutputExpressionMappings();
        for (Entry<String, ExpressionMapping> entry : inputs.entrySet()) {
            List<Object> list = getList(message, Collections.singletonList(entry.getValue()));
            final Object output;
            switch (list.size()) {
            case 0:
                output = null;
                break;
            case 1:
                output = list.get(0);
                break;
            default:
                output = list;
            }
            map.put(entry.getKey(), output);
        }
        return map;
    }
839382
public java.util.Map<java.lang.String, java.lang.String> getTagsMap() {
    return internalGetTags().getMap();
  }
318567
public Map<String, String> getValueMap() {
        if (tokensMap == null) {
            return null;
        }
        if (tokensMap.isEmpty()) {
            return new LinkedHashMap<>();
        } else {
            Map<String, String> map = new LinkedHashMap<>(tokensMap.size());
            for (Map.Entry<String, Token[]> entry : tokensMap.entrySet()) {
                map.put(entry.getKey(), TokenParser.toString(entry.getValue()));
            }
            return map;
        }
    }
217424
public static List<EventSubscriptionEntity> collectCompensateEventSubscriptionsForActivity(ActivityExecution execution, String activityRef) {

    final List<EventSubscriptionEntity> eventSubscriptions = collectCompensateEventSubscriptionsForScope(execution);
    final String subscriptionActivityId = getSubscriptionActivityId(execution, activityRef);

    List<EventSubscriptionEntity> eventSubscriptionsForActivity = new ArrayList<EventSubscriptionEntity>();
    for (EventSubscriptionEntity subscription : eventSubscriptions) {
      if (subscriptionActivityId.equals(subscription.getActivityId())) {
        eventSubscriptionsForActivity.add(subscription);
      }
    }
    return eventSubscriptionsForActivity;
  }
269013
@Override
    public Map<String, String> getValues() {
        HashMap<String, String> result = new HashMap<>();

        if (status != null && status != TransactionStatus.NotSpecified) result.put("Status", status.toString());
        if (type != null && type != TransactionType.NotSpecified) result.put("Type", type.toString());
        if (nature != null && nature != TransactionNature.NotSpecified) result.put("Nature", nature.toString());
        if (beforeDate != null) result.put("BeforeDate", Long.toString(beforeDate));
        if (afterDate != null) result.put("AfterDate", Long.toString(afterDate));

        return result;
    }
18468
private String getActivityID(Task task)
   {
      String result = null;
      if (m_activityIDField != null)
      {
         Object value = task.getCachedValue(m_activityIDField);
         if (value != null)
         {
            result = value.toString();
         }
      }
      return result;
   }