Extracts a list of tagk/tagv pairs from a tsuid
@param tsuid The tsuid to parse
@return A list of tagk/tagv UID pairs
@throws IllegalArgumentException if the TSUID is malformed
@since 2.0
764277
public static List<byte[]> getTagPairsFromTSUID(final byte[] tsuid) {
    if (tsuid == null) {
      throw new IllegalArgumentException("Missing TSUID");
    }
    if (tsuid.length <= TSDB.metrics_width()) {
      throw new IllegalArgumentException(
          "TSUID is too short, may be missing tags");
    }
     
    final List<byte[]> tags = new ArrayList<byte[]>();
    final int pair_width = TSDB.tagk_width() + TSDB.tagv_width();
    
    // start after the metric then iterate over each tagk/tagv pair
    for (int i = TSDB.metrics_width(); i < tsuid.length; i+= pair_width) {
      if (i + pair_width > tsuid.length){
        throw new IllegalArgumentException(
            "The TSUID appears to be malformed, improper tag width");
      }
      tags.add(Arrays.copyOfRange(tsuid, i, i + pair_width));
    }
    return tags;
  }
1279808
public java.util.List<Tag> getTagList() {
        if (tagList == null) {
            tagList = new com.amazonaws.internal.SdkInternalList<Tag>();
        }
        return tagList;
    }
574117
public void addNotMatched(final String tsuid, final String message) {
    if (tsuid == null || tsuid.isEmpty()) {
      throw new IllegalArgumentException("Empty or null non matches not allowed");
    }
    if (not_matched == null) {
      not_matched = new HashMap<String, String>();
    }
    if (!not_matched.containsKey(tsuid)) {
      not_matched.put(tsuid, message);
      changed.put("not_matched", true);
    }
  }
1192506
public List<Integer> getUserTags(String openId) {
        String url = WxEndpoint.get("url.tag.user.gettag");
        Map<String, Object> map = new HashMap<>();
        map.put("openid", openId);
        String response = wxClient.post(url, JsonMapper.nonEmptyMapper().toJson(map));
        TagIdsWrapper tagIdsWrapper = JsonMapper.defaultMapper().fromJson(response, TagIdsWrapper.class);
        return tagIdsWrapper.getList();
    }
271344
@Override
    public T get(final UUID _uuid)
    {
        if (!hasEntries()) {
            initialize(AbstractAutomaticCache.class);
        }
        return getCache4UUID().get(_uuid);
    }
996504
public static boolean isUuid(final String uuid) {
        return uuid != null && (uuid.length() == 36 || uuid.length() == 32)
                && UUID_PATTERN.matcher(uuid).matches();
    }
927520
public static <T> Map<? extends String, T> toMap(List<Tag<T>> tags) {
    ImmutableMap.Builder<String, T> tagsMapBuilder = ImmutableMap.builder();
    for (Tag<T> tag : tags) {
      tagsMapBuilder.put(tag.getKey(), tag.getValue());
    }
    return tagsMapBuilder.build();
  }
911447
public List<String> extractIdList(SearchResponse searchResponse) {
        return Arrays.stream(searchResponse.getHits().getHits())
                .map(SearchHit::getId).collect(toList());
    }
561635
private List<CmsUUID> internalReadUUIDList(ObjectInput in) throws IOException {

        List<CmsUUID> result = null;

        int i = in.readInt();
        if (i >= 0) {
            result = new ArrayList<CmsUUID>();
            while (i > 0) {
                result.add(internalReadUUID(in));
                i--;
            }
        }

        return result;
    }
691316
public static List<TagEntryAO> tagsMapToTagEntries(Map<String, String> tagsMap) {

    	if (tagsMap==null)
    		return Collections.EMPTY_LIST;

        List<TagEntryAO> tagEntries = new ArrayList<>(tagsMap.size());

        for (Map.Entry<String,String> entry : tagsMap.entrySet())
            tagEntries.add(
                    new TagEntryAO(entry.getKey(), entry.getValue())
            );

        return tagEntries;

    }
1220209
public static final void uuid(String uuid)
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "uuid", uuid);

        _uuid = uuid;

        if (tc.isEntryEnabled())
            Tr.exit(tc, "uuid");
    }
284064
public List<TagCount> getTagsOnSpace(int spaceId) {
		return getResourceFactory()
				.getApiResource("/tag/space/" + spaceId + "/")
				.get(new GenericType<List<TagCount>>() { });
	}
631284
public CustomIcon getIconByUuid(UUID uuid) {
        for (CustomIcon customIcon : customIconList) {
            if (customIcon.getUuid() != null && customIcon.getUuid().compareTo(uuid) == 0) {
                return customIcon;
            }
        }

        return null;
    }
1023371
public static List<String> getTags() {
		List<String> tags = new ArrayList<String>();
		for (String writerProperty : Configuration.getSiblings("writer").keySet()) {
			String tag = Configuration.get(writerProperty + ".tag");
			if (tag != null && !tag.isEmpty() && !tag.equals("-") && !tags.contains(tag)) {
				tags.add(tag);
			}
		}
		return tags;
	}
1014436
public java.util.List<String> getGpuIds() {
        if (gpuIds == null) {
            gpuIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return gpuIds;
    }
438632
private List<String> extractTagsAndResetLastTagsLineField() {
        String tags = lastTagsLine;
        List<String> result = extractTags(tags);
        resetLastTagsLine();
        return result;
    }
1304319
public static Collection<String> getTagNames(Channel channel) {
		Collection<String> tagNames = new HashSet<String>();
		for (Tag tag : channel.getTags()) {
			tagNames.add(tag.getName());
		}
		return tagNames;
	}