How to use

getUuid

method

in

com.netflix.imfutility.cpl.uuid.SequenceUUID

/**
 * Create xml channel info form input pair.
 *
 * @param pair
 * @return xml ChannelType object
 */
private ChannelType createXmlChannel(Pair<SequenceUUID, Integer> pair) {
  ChannelType channel = new ChannelType();
  channel.setCPLVirtualTrackId(pair.getLeft().getUuid());
  channel.setCPLVirtualTrackChannel(pair.getRight());
  return channel;
}

private static String uuid(int seqNum) {
  return getSequenceUuid(seqNum, SequenceType.AUDIO).getUuid();
}

private LinkedHashMap<String, Integer> getChannelsForTracks() {
  LinkedHashMap<String, Integer> result = new LinkedHashMap<>();
  SequenceTemplateParameterContext sequenceContext = contextProvider.getSequenceContext();
  for (SequenceUUID uuid : sequenceContext.getUuids(SequenceType.AUDIO)) {
    String channelsNum = sequenceContext.getParameterValue(
        SequenceContextParameters.CHANNELS_NUM,
        new ContextInfoBuilder().setSequenceType(SequenceType.AUDIO).setSequenceUuid(uuid).build());
    result.put(uuid.getUuid(), Integer.valueOf(channelsNum));
  }
  return result;
}

/**
 * Inits a sequence (virtual track) parameter defined by the given UUID. Defines default parameters
 * (such as Sequence UUID, type and number).
 * The method must be called for each sequence before adding another parameters.
 *
 * @param seqType sequence type
 * @param uuid    sequence UUID.
 * @return this sequence template parameters context.
 */
public SequenceTemplateParameterContext initSequence(SequenceType seqType, SequenceUUID uuid) {
  if (!sequences.containsKey(seqType) || !sequences.get(seqType).contains(uuid)) {
    int seqNum = getSequenceCount(seqType);
    doAddParameter(seqType, uuid, SequenceContextParameters.UUID, uuid.getUuid());
    doAddParameter(seqType, uuid, SequenceContextParameters.TYPE, seqType.value());
    doAddParameter(seqType, uuid, SequenceContextParameters.NUM, String.valueOf(seqNum));
  }
  return this;
}

/**
 * Gets map of CPL virtual track UUID to virtual track channels number by order.
 *
 * @return map of CPL virtual track UUID to virtual track channels number by order
 */
private LinkedHashMap<String, Integer> getVirtualTrackChannels() {
  LinkedHashMap<String, Integer> result = new LinkedHashMap<>();
  SequenceTemplateParameterContext sequenceContext = contextProvider.getSequenceContext();
  for (SequenceUUID uuid : sequenceContext.getUuids(SequenceType.AUDIO)) {
    String channelsNum = sequenceContext.getParameterValue(
        SequenceContextParameters.CHANNELS_NUM,
        new ContextInfoBuilder().setSequenceType(SequenceType.AUDIO).setSequenceUuid(uuid).build());
    result.put(uuid.getUuid(), Integer.valueOf(channelsNum));
  }
  return result;
}

.map(pair -> {
  ChannelType channel = new ChannelType();
  channel.setCPLVirtualTrackId(pair.getLeft().getUuid());
  channel.setCPLVirtualTrackChannel(pair.getRight());
  return channel;

private void checkEBUTrack(AudioMapType audioMap, int trackNum, int audioSeqNum, Integer channelsNum) {
  assertEquals(trackNum + 1, audioMap.getEBUTrack().get(trackNum).getNumber());
  assertEquals(getSequenceUuid(audioSeqNum, SequenceType.AUDIO).getUuid(),
      audioMap.getEBUTrack().get(trackNum).getCPLVirtualTrackId());
  assertEquals(channelsNum, audioMap.getEBUTrack().get(trackNum).getCPLVirtualTrackChannel());
}

public static EBUTrackType createEbuTrack(int num, ImmutablePair<SequenceUUID, Integer> input) {
  EBUTrackType ebuTrack = new EBUTrackType();
  ebuTrack.setNumber(num);
  ebuTrack.setCPLVirtualTrackId(input.getLeft().getUuid());
  ebuTrack.setCPLVirtualTrackChannel(input.getRight());
  return ebuTrack;
}

@Test
public void resolvesCorrectSequenceContext() {
  for (SequenceType seqType : SEQUENCE_TYPES) {
    for (int seq = 0; seq < SEQ_COUNT; seq++) {
      ContextInfo contextInfo = new ContextInfoBuilder()
          .setSequenceUuid(getSequenceUuid(seq, seqType))
          .setSequenceType(seqType).build();
      String resolvedNum = resolver.resolveTemplateParameter("%{seq.num}", contextInfo);
      String resolvedType = resolver.resolveTemplateParameter("%{seq.type}", contextInfo);
      String resolvedUuid = resolver.resolveTemplateParameter("%{seq.uuid}", contextInfo);
      assertNotNull(resolvedNum);
      assertEquals(String.valueOf(seq), resolvedNum);
      assertNotNull(resolvedType);
      assertEquals(seqType.value(), resolvedType);
      assertNotNull(resolvedUuid);
      assertEquals(getSequenceUuid(seq, seqType).getUuid(), resolvedUuid);
    }
  }
}

private void assertDefaultSequenceParameters(TemplateParameterContextProvider contextProvider, int seqNum,
                       SequenceUUID seqUuid, SequenceType seqType) {
  assertEquals(
      String.valueOf(seqNum),
      contextProvider.getSequenceContext().resolveTemplateParameter(
          new TemplateParameter("%{seq.num}"),
          new ContextInfoBuilder().setSequenceUuid(seqUuid).setSequenceType(seqType).build()));
  assertEquals(
      seqUuid.getUuid(),
      contextProvider.getSequenceContext().resolveTemplateParameter(
          new TemplateParameter("%{seq.uuid}"),
          new ContextInfoBuilder().setSequenceUuid(seqUuid).setSequenceType(seqType).build()));
  assertEquals(
      seqType.value(),
      contextProvider.getSequenceContext().resolveTemplateParameter(
          new TemplateParameter("%{seq.type}"),
          new ContextInfoBuilder().setSequenceUuid(seqUuid).setSequenceType(seqType).build()));
}