HADOOP-544. Committing the files I missed in the first commit of the patch.

git-svn-id: https://svn.apache.org/repos/asf/hadoop/core/trunk@652378 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/hadoop/mapred/ID.java

@@ -0,0 +1,111 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.mapred;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.WritableComparable;
+
+/**
+ * A general identifier, which internally stores the id
+ * as an integer. This is the super class of {@link JobID}, 
+ * {@link TaskID} and {@link TaskAttemptID}.
+ * 
+ * @see JobID
+ * @see TaskID
+ * @see TaskAttemptID
+ */
+public class ID implements WritableComparable<ID> {
+  protected int id;
+
+  /** constructs an ID object from the given int */
+  public ID(int id) {
+    this.id = id;
+  }
+
+  protected ID() {
+  }
+
+  /** returns the int which represents the identifier */
+  public int getId() {
+    return id;
+  }
+
+  @Override
+  public String toString() {
+    return String.valueOf(id);
+  }
+
+  @Override
+  public int hashCode() {
+    return Integer.valueOf(id).hashCode();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if(o == null)
+      return false;
+    if (o.getClass().equals(ID.class)) {
+      ID that = (ID) o;
+      return this.id == that.id;
+    }
+    else
+      return false;
+  }
+
+  /** Compare IDs by associated numbers */
+  public int compareTo(ID that) {
+    return this.id - that.id;
+  }
+
+  public void readFields(DataInput in) throws IOException {
+    this.id = in.readInt();
+  }
+
+  public void write(DataOutput out) throws IOException {
+    out.writeInt(id);
+  }
+
+  public static ID read(DataInput in) throws IOException {
+    ID id = new ID();
+    id.readFields(in);
+    return id;
+  }
+
+  /**
+   * Construct an ID object from given string
+   * 
+   * @return constructed Id object or null if the given String is null
+   * @throws IllegalArgumentException if the given string is malformed
+   */
+  public static ID forName(String str) throws IllegalArgumentException {
+    if (str == null)
+      return null;
+    try {
+      int id = Integer.parseInt(str);
+      return new ID(id);
+    }
+    catch (Exception ex) {
+      throw new IllegalArgumentException("Id string : " + str
+          + " is not propoerly formed");
+    }
+  }
+}

src/java/org/apache/hadoop/mapred/JobID.java

@@ -0,0 +1,183 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.mapred;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.text.NumberFormat;
+
+import org.apache.hadoop.io.Text;
+
+/**
+ * JobID represents the immutable and unique identifier for 
+ * the job. JobID consists of two parts. First part 
+ * represents the jobtracker identifier, so that jobID to jobtracker map 
+ * is defined. For cluster setup this string is the jobtracker 
+ * start time, for local setting, it is "local".
+ * Second part of the JobID is the job number. <br> 
+ * An example JobID is : 
+ * <code>job_200707121733_0003</code> , which represents the third job 
+ * running at the jobtracker started at <code>200707121733</code>. 
+ * <p>
+ * Applications should never construct or parse JobID strings, but rather 
+ * use appropriate constructors or {@link #forName(String)} method. 
+ * 
+ * @see TaskID
+ * @see TaskAttemptID
+ * @see JobTracker#getNewJobId()
+ * @see JobTracker#getStartTime()
+ */
+public class JobID extends ID {
+  private static final String JOB = "job";
+  private String jtIdentifier;
+  private static char UNDERSCORE = '_';
+  
+  private static NumberFormat idFormat = NumberFormat.getInstance();
+  static {
+    idFormat.setGroupingUsed(false);
+    idFormat.setMinimumIntegerDigits(4);
+  }
+  
+  /**
+   * Constructs a JobID object 
+   * @param jtIdentifier jobTracker identifier
+   * @param id job number
+   */
+  public JobID(String jtIdentifier, int id) {
+    super(id);
+    this.jtIdentifier = jtIdentifier;
+  }
+  
+  private JobID() { }
+  
+  public String getJtIdentifier() {
+    return jtIdentifier;
+  }
+  
+  @Override
+  public boolean equals(Object o) {
+    if(o == null)
+      return false;
+    if(o.getClass().equals(JobID.class)) {
+      JobID that = (JobID)o;
+      return this.id==that.id
+        && this.jtIdentifier.equals(that.jtIdentifier);
+    }
+    else return false;
+  }
+  
+  /**Compare JobIds by first jtIdentifiers, then by job numbers*/
+  @Override
+  public int compareTo(ID o) {
+    JobID that = (JobID)o;
+    int jtComp = this.jtIdentifier.compareTo(that.jtIdentifier);
+    if(jtComp == 0) {
+      return this.id - that.id;
+    }
+    else return jtComp;
+  }
+  
+  @Override
+  public String toString() {
+    StringBuilder builder = new StringBuilder();
+    return builder.append(JOB).append(UNDERSCORE)
+      .append(toStringWOPrefix()).toString();
+  }
+  
+  /** Returns the string representation w/o prefix */
+  StringBuilder toStringWOPrefix() {
+    StringBuilder builder = new StringBuilder();
+    builder.append(jtIdentifier).append(UNDERSCORE)
+    .append(idFormat.format(id)).toString();
+    return builder;
+  }
+  
+  @Override
+  public int hashCode() {
+    return toStringWOPrefix().toString().hashCode();
+  }
+  
+  @Override
+  public void readFields(DataInput in) throws IOException {
+    super.readFields(in);
+    this.jtIdentifier = Text.readString(in);
+  }
+
+  @Override
+  public void write(DataOutput out) throws IOException {
+    super.write(out);
+    Text.writeString(out, jtIdentifier);
+  }
+  
+  public static JobID read(DataInput in) throws IOException {
+    JobID jobId = new JobID();
+    jobId.readFields(in);
+    return jobId;
+  }
+  
+  /** Construct a JobId object from given string 
+   * @return constructed JobId object or null if the given String is null
+   * @throws IllegalArgumentException if the given string is malformed
+   */
+  public static JobID forName(String str) throws IllegalArgumentException {
+    if(str == null)
+      return null;
+    try {
+      String[] parts = str.split("_");
+      if(parts.length == 3) {
+        if(parts[0].equals(JOB)) {
+          return new JobID(parts[1], Integer.parseInt(parts[2]));
+        }
+      }
+    }catch (Exception ex) {//fall below
+    }
+    throw new IllegalArgumentException("JobId string : " + str 
+        + " is not properly formed");
+  }
+  
+  /** 
+   * Returns a regex pattern which matches task IDs. Arguments can 
+   * be given null, in which case that part of the regex will be generic.  
+   * For example to obtain a regex matching <i>any job</i> 
+   * run on the jobtracker started at <i>200707121733</i>, we would use :
+   * <pre> 
+   * JobID.getTaskIDsPattern("200707121733", null);
+   * </pre>
+   * which will return :
+   * <pre> "job_200707121733_[0-9]*" </pre> 
+   * @param jtIdentifier jobTracker identifier, or null
+   * @param jobId job number, or null
+   * @return a regex pattern matching JobIDs
+   */
+  public static String getJobIDsPattern(String jtIdentifier, Integer jobId) {
+    StringBuilder builder = new StringBuilder(JOB).append(UNDERSCORE);
+    builder.append(getJobIDsPatternWOPrefix(jtIdentifier, jobId));
+    return builder.toString();
+  }
+  
+  static StringBuilder getJobIDsPatternWOPrefix(String jtIdentifier
+      , Integer jobId) {
+    StringBuilder builder = new StringBuilder()
+      .append(jtIdentifier != null ? jtIdentifier : "[^_]*").append(UNDERSCORE)
+      .append(jobId != null ? idFormat.format(jobId) : "[0-9]*");
+    return builder;
+  }
+  
+}

src/java/org/apache/hadoop/mapred/TaskAttemptID.java

@@ -0,0 +1,212 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.mapred;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * TaskAttemptID represents the immutable and unique identifier for 
+ * a task attempt. Each task attempt is one particular instance of a Map or
+ * Reduce Task identified by its TaskID. 
+ * 
+ * TaskAttemptID consists of 2 parts. First part is the 
+ * {@link TaskID}, that this TaskAttemptID belongs to.
+ * Second part is the task attempt number. <br> 
+ * An example TaskAttemptID is : 
+ * <code>attempt_200707121733_0003_m_000005_0</code> , which represents the
+ * zeroth task attempt for the fifth map task in the third job 
+ * running at the jobtracker started at <code>200707121733</code>. 
+ * <p>
+ * Applications should never construct or parse TaskAttemptID strings
+ * , but rather use appropriate constructors or {@link #forName(String)} 
+ * method. 
+ * 
+ * @see JobID
+ * @see TaskID
+ */
+public class TaskAttemptID extends ID {
+  private static final String ATTEMPT = "attempt";
+  private TaskID taskId;
+  private static final char UNDERSCORE = '_';
+  
+  /**
+   * Constructs a TaskAttemptID object from given {@link TaskID}.  
+   * @param taskId TaskID that this task belongs to  
+   * @param id the task attempt number
+   */
+  public TaskAttemptID(TaskID taskId, int id) {
+    super(id);
+    if(taskId == null) {
+      throw new IllegalArgumentException("taskId cannot be null");
+    }
+    this.taskId = taskId;
+  }
+  
+  /**
+   * Constructs a TaskId object from given parts.
+   * @param jtIdentifier jobTracker identifier
+   * @param jobId job number 
+   * @param isMap whether the tip is a map 
+   * @param taskId taskId number
+   * @param id the task attempt number
+   */
+  public TaskAttemptID(String jtIdentifier, int jobId, boolean isMap
+      , int taskId, int id) {
+    this(new TaskID(jtIdentifier, jobId, isMap, taskId), id);
+  }
+  
+  private TaskAttemptID() { }
+  
+  /** Returns the {@link JobID} object that this task attempt belongs to */
+  public JobID getJobID() {
+    return taskId.getJobID();
+  }
+  
+  /** Returns the {@link TaskID} object that this task attempt belongs to */
+  public TaskID getTaskID() {
+    return taskId;
+  }
+  
+  /**Returns whether this TaskAttemptID is a map ID */
+  public boolean isMap() {
+    return taskId.isMap();
+  }
+  
+  @Override
+  public boolean equals(Object o) {
+    if(o == null)
+      return false;
+    if(o.getClass().equals(TaskAttemptID.class)) {
+      TaskAttemptID that = (TaskAttemptID)o;
+      return this.id==that.id
+        && this.taskId.equals(that.taskId);
+    }
+    else return false;
+  }
+  
+  /**Compare TaskIds by first tipIds, then by task numbers. */
+  @Override
+  public int compareTo(ID o) {
+    TaskAttemptID that = (TaskAttemptID)o;
+    int tipComp = this.taskId.compareTo(that.taskId);
+    if(tipComp == 0) {
+      return this.id - that.id;
+    }
+    else return tipComp;
+  }
+  @Override
+  public String toString() { 
+    StringBuilder builder = new StringBuilder();
+    return builder.append(ATTEMPT).append(UNDERSCORE)
+      .append(toStringWOPrefix()).toString();
+  }
+
+  StringBuilder toStringWOPrefix() {
+    StringBuilder builder = new StringBuilder();
+    return builder.append(taskId.toStringWOPrefix())
+      .append(UNDERSCORE).append(id);
+  }
+  
+  @Override
+  public int hashCode() {
+    return toStringWOPrefix().toString().hashCode();
+  }
+  
+  @Override
+  public void readFields(DataInput in) throws IOException {
+    super.readFields(in);
+    this.taskId = TaskID.read(in);
+  }
+
+  @Override
+  public void write(DataOutput out) throws IOException {
+    super.write(out);
+    taskId.write(out);
+  }
+  
+  public static TaskAttemptID read(DataInput in) throws IOException {
+    TaskAttemptID taskId = new TaskAttemptID();
+    taskId.readFields(in);
+    return taskId;
+  }
+  
+  /** Construct a TaskAttemptID object from given string 
+   * @return constructed TaskAttemptID object or null if the given String is null
+   * @throws IllegalArgumentException if the given string is malformed
+   */
+  public static TaskAttemptID forName(String str) throws IllegalArgumentException {
+    if(str == null)
+      return null;
+    try {
+      String[] parts = str.split("_");
+      if(parts.length == 6) {
+        if(parts[0].equals(ATTEMPT)) {
+          boolean isMap = false;
+          if(parts[3].equals("m")) isMap = true;
+          else if(parts[3].equals("r")) isMap = false;
+          else throw new Exception();
+          return new TaskAttemptID(parts[1], Integer.parseInt(parts[2]),
+              isMap, Integer.parseInt(parts[4]), Integer.parseInt(parts[5]));
+        }
+      }
+    }catch (Exception ex) {//fall below
+    }
+    throw new IllegalArgumentException("TaskAttemptId string : " + str 
+        + " is not properly formed");
+  }
+  
+  /** 
+   * Returns a regex pattern which matches task attempt IDs. Arguments can 
+   * be given null, in which case that part of the regex will be generic.  
+   * For example to obtain a regex matching <i>all task attempt IDs</i> 
+   * of <i>any jobtracker</i>, in <i>any job</i>, of the <i>first 
+   * map task</i>, we would use :
+   * <pre> 
+   * TaskAttemptID.getTaskAttemptIDsPattern(null, null, true, 1, null);
+   * </pre>
+   * which will return :
+   * <pre> "attempt_[^_]*_[0-9]*_m_000001_[0-9]*" </pre> 
+   * @param jtIdentifier jobTracker identifier, or null
+   * @param jobId job number, or null
+   * @param isMap whether the tip is a map, or null 
+   * @param taskId taskId number, or null
+   * @param attemptId the task attempt number, or null
+   * @return a regex pattern matching TaskAttemptIDs
+   */
+  public static String getTaskAttemptIDsPattern(String jtIdentifier,
+      Integer jobId, Boolean isMap, Integer taskId, Integer attemptId) {
+    StringBuilder builder = new StringBuilder(ATTEMPT).append(UNDERSCORE);
+    builder.append(getTaskAttemptIDsPatternWOPrefix(jtIdentifier, jobId,
+        isMap, taskId, attemptId));
+    return builder.toString();
+  }
+  
+  static StringBuilder getTaskAttemptIDsPatternWOPrefix(String jtIdentifier
+      , Integer jobId, Boolean isMap, Integer taskId, Integer attemptId) {
+    StringBuilder builder = new StringBuilder();
+    builder.append(TaskID.getTaskIDsPatternWOPrefix(jtIdentifier
+        , jobId, isMap, taskId))
+        .append(UNDERSCORE)
+        .append(attemptId != null ? attemptId : "[0-9]*");
+    return builder;
+  }
+  
+}

src/java/org/apache/hadoop/mapred/TaskID.java

@@ -0,0 +1,224 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.mapred;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.text.NumberFormat;
+
+/**
+ * TaskID represents the immutable and unique identifier for 
+ * a Map or Reduce Task. Each TaskID encompasses multiple attempts made to
+ * execute the Map or Reduce Task, each of which are uniquely indentified by
+ * their TaskAttemptID.
+ * 
+ * TaskID consists of 3 parts. First part is the {@link JobID}, that this 
+ * TaskInProgress belongs to. Second part of the TaskID is either 'm' or 'r' 
+ * representing whether the task is a map task or a reduce task. 
+ * And the third part is the task number. <br> 
+ * An example TaskID is : 
+ * <code>task_200707121733_0003_m_000005</code> , which represents the
+ * fifth map task in the third job running at the jobtracker 
+ * started at <code>200707121733</code>. 
+ * <p>
+ * Applications should never construct or parse TaskID strings
+ * , but rather use appropriate constructors or {@link #forName(String)} 
+ * method. 
+ * 
+ * @see JobID
+ * @see TaskAttemptID
+ */
+public class TaskID extends ID {
+  private static final String TASK = "task";
+  private static char UNDERSCORE = '_';  
+  private static NumberFormat idFormat = NumberFormat.getInstance();
+  static {
+    idFormat.setGroupingUsed(false);
+    idFormat.setMinimumIntegerDigits(6);
+  }
+  
+  private JobID jobId;
+  private boolean isMap;
+
+  /**
+   * Constructs a TaskID object from given {@link JobID}.  
+   * @param jobId JobID that this tip belongs to 
+   * @param isMap whether the tip is a map 
+   * @param id the tip number
+   */
+  public TaskID(JobID jobId, boolean isMap, int id) {
+    super(id);
+    if(jobId == null) {
+      throw new IllegalArgumentException("jobId cannot be null");
+    }
+    this.jobId = jobId;
+    this.isMap = isMap;
+  }
+  
+  /**
+   * Constructs a TaskInProgressId object from given parts.
+   * @param jtIdentifier jobTracker identifier
+   * @param jobId job number 
+   * @param isMap whether the tip is a map 
+   * @param id the tip number
+   */
+  public TaskID(String jtIdentifier, int jobId, boolean isMap, int id) {
+    this(new JobID(jtIdentifier, jobId), isMap, id);
+  }
+  
+  private TaskID() { }
+  
+  /** Returns the {@link JobID} object that this tip belongs to */
+  public JobID getJobID() {
+    return jobId;
+  }
+  
+  /**Returns whether this TaskID is a map ID */
+  public boolean isMap() {
+    return isMap;
+  }
+  
+  @Override
+  public boolean equals(Object o) {
+    if(o == null)
+      return false;
+    if(o.getClass().equals(TaskID.class)) {
+      TaskID that = (TaskID)o;
+      return this.id==that.id
+        && this.isMap == that.isMap
+        && this.jobId.equals(that.jobId);
+    }
+    else return false;
+  }
+
+  /**Compare TaskInProgressIds by first jobIds, then by tip numbers. Reduces are 
+   * defined as greater then maps.*/
+  @Override
+  public int compareTo(ID o) {
+    TaskID that = (TaskID)o;
+    int jobComp = this.jobId.compareTo(that.jobId);
+    if(jobComp == 0) {
+      if(this.isMap == that.isMap) {
+        return this.id - that.id;
+      }
+      else return this.isMap ? -1 : 1;
+    }
+    else return jobComp;
+  }
+  
+  @Override
+  public String toString() { 
+    StringBuilder builder = new StringBuilder();
+    return builder.append(TASK).append(UNDERSCORE)
+      .append(toStringWOPrefix()).toString();
+  }
+
+  StringBuilder toStringWOPrefix() {
+    StringBuilder builder = new StringBuilder();
+    builder.append(jobId.toStringWOPrefix())
+      .append(isMap ? "_m_" : "_r_");
+    return builder.append(idFormat.format(id));
+  }
+  
+  @Override
+  public int hashCode() {
+    return toStringWOPrefix().toString().hashCode();
+  }
+  
+  @Override
+  public void readFields(DataInput in) throws IOException {
+    super.readFields(in);
+    this.jobId = JobID.read(in);
+    this.isMap = in.readBoolean();
+  }
+
+  @Override
+  public void write(DataOutput out) throws IOException {
+    super.write(out);
+    jobId.write(out);
+    out.writeBoolean(isMap);
+  }
+  
+  public static TaskID read(DataInput in) throws IOException {
+    TaskID tipId = new TaskID();
+    tipId.readFields(in);
+    return tipId;
+  }
+  
+  /** Construct a TaskID object from given string 
+   * @return constructed TaskID object or null if the given String is null
+   * @throws IllegalArgumentException if the given string is malformed
+   */
+  public static TaskID forName(String str) 
+    throws IllegalArgumentException {
+    if(str == null)
+      return null;
+    try {
+      String[] parts = str.split("_");
+      if(parts.length == 5) {
+        if(parts[0].equals(TASK)) {
+          boolean isMap = false;
+          if(parts[3].equals("m")) isMap = true;
+          else if(parts[3].equals("r")) isMap = false;
+          else throw new Exception();
+          return new TaskID(parts[1], Integer.parseInt(parts[2]),
+              isMap, Integer.parseInt(parts[4]));
+        }
+      }
+    }catch (Exception ex) {//fall below
+    }
+    throw new IllegalArgumentException("TaskId string : " + str 
+        + " is not properly formed");
+  }
+  
+  /** 
+   * Returns a regex pattern which matches task IDs. Arguments can 
+   * be given null, in which case that part of the regex will be generic.  
+   * For example to obtain a regex matching <i>the first map task</i> 
+   * of <i>any jobtracker</i>, of <i>any job</i>, we would use :
+   * <pre> 
+   * TaskID.getTaskIDsPattern(null, null, true, 1);
+   * </pre>
+   * which will return :
+   * <pre> "task_[^_]*_[0-9]*_m_000001*" </pre> 
+   * @param jtIdentifier jobTracker identifier, or null
+   * @param jobId job number, or null
+   * @param isMap whether the tip is a map, or null 
+   * @param taskId taskId number, or null
+   * @return a regex pattern matching TaskIDs
+   */
+  public static String getTaskIDsPattern(String jtIdentifier, Integer jobId
+      , Boolean isMap, Integer taskId) {
+    StringBuilder builder = new StringBuilder(TASK).append(UNDERSCORE)
+      .append(getTaskIDsPatternWOPrefix(jtIdentifier, jobId, isMap, taskId));
+    return builder.toString();
+  }
+  
+  static StringBuilder getTaskIDsPatternWOPrefix(String jtIdentifier
+      , Integer jobId, Boolean isMap, Integer taskId) {
+    StringBuilder builder = new StringBuilder();
+    builder.append(JobID.getJobIDsPatternWOPrefix(jtIdentifier, jobId))
+      .append(UNDERSCORE)
+      .append(isMap != null ? (isMap ? "m" : "r") : "(m|r)").append(UNDERSCORE)
+      .append(taskId != null ? idFormat.format(taskId) : "[0-9]*");
+    return builder;
+  }
+  
+}