hadoop-mapreduce/hadoop-mr-client/hadoop-mapreduce-client-common/src/main/java/org/apache/hadoop/mapreduce/v2/api/records/impl/pb/TaskReportPBImpl.java

package org.apache.hadoop.mapreduce.v2.api.records.impl.pb;


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.hadoop.mapreduce.v2.api.records.Counters;
import org.apache.hadoop.mapreduce.v2.api.records.TaskAttemptId;
import org.apache.hadoop.mapreduce.v2.api.records.TaskId;
import org.apache.hadoop.mapreduce.v2.api.records.TaskReport;
import org.apache.hadoop.mapreduce.v2.api.records.TaskState;
import org.apache.hadoop.mapreduce.v2.proto.MRProtos.CountersProto;
import org.apache.hadoop.mapreduce.v2.proto.MRProtos.TaskAttemptIdProto;
import org.apache.hadoop.mapreduce.v2.proto.MRProtos.TaskIdProto;
import org.apache.hadoop.mapreduce.v2.proto.MRProtos.TaskReportProto;
import org.apache.hadoop.mapreduce.v2.proto.MRProtos.TaskReportProtoOrBuilder;
import org.apache.hadoop.mapreduce.v2.proto.MRProtos.TaskStateProto;
import org.apache.hadoop.mapreduce.v2.util.MRProtoUtils;
import org.apache.hadoop.yarn.api.records.ProtoBase;


    
public class TaskReportPBImpl extends ProtoBase<TaskReportProto> implements TaskReport {
  TaskReportProto proto = TaskReportProto.getDefaultInstance();
  TaskReportProto.Builder builder = null;
  boolean viaProto = false;
  
  private TaskId taskId = null;
  private Counters counters = null;
  private List<TaskAttemptId> runningAttempts = null;
  private TaskAttemptId successfulAttemptId = null;
  private List<String> diagnostics = null;
  
  
  public TaskReportPBImpl() {
    builder = TaskReportProto.newBuilder();
  }

  public TaskReportPBImpl(TaskReportProto proto) {
    this.proto = proto;
    viaProto = true;
  }
  
  public TaskReportProto getProto() {
      mergeLocalToProto();
    proto = viaProto ? proto : builder.build();
    viaProto = true;
    return proto;
  }

  private void mergeLocalToBuilder() {
    if (this.taskId != null) {
      builder.setTaskId(convertToProtoFormat(this.taskId));
    }
    if (this.counters != null) {
      builder.setCounters(convertToProtoFormat(this.counters));
    }
    if (this.runningAttempts != null) {
      addRunningAttemptsToProto();
    }
    if (this.successfulAttemptId != null) {
      builder.setSuccessfulAttempt(convertToProtoFormat(this.successfulAttemptId));
    }
    if (this.diagnostics != null) {
      addDiagnosticsToProto();
    }
  }

  private void mergeLocalToProto() {
    if (viaProto) 
      maybeInitBuilder();
    mergeLocalToBuilder();
    proto = builder.build();
    viaProto = true;
  }

  private void maybeInitBuilder() {
    if (viaProto || builder == null) {
      builder = TaskReportProto.newBuilder(proto);
    }
    viaProto = false;
  }
    
  
  @Override
  public Counters getCounters() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    if (this.counters != null) {
      return this.counters;
    }
    if (!p.hasCounters()) {
      return null;
    }
    this.counters = convertFromProtoFormat(p.getCounters());
    return this.counters;
  }

  @Override
  public void setCounters(Counters counters) {
    maybeInitBuilder();
    if (counters == null) 
      builder.clearCounters();
    this.counters = counters;
  }
  @Override
  public long getStartTime() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    return (p.getStartTime());
  }

  @Override
  public void setStartTime(long startTime) {
    maybeInitBuilder();
    builder.setStartTime((startTime));
  }
  @Override
  public long getFinishTime() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    return (p.getFinishTime());
  }

  @Override
  public void setFinishTime(long finishTime) {
    maybeInitBuilder();
    builder.setFinishTime((finishTime));
  }
  @Override
  public TaskId getTaskId() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    if (this.taskId != null) {
      return this.taskId;
    }
    if (!p.hasTaskId()) {
      return null;
    }
    this.taskId = convertFromProtoFormat(p.getTaskId());
    return this.taskId;
  }

  @Override
  public void setTaskId(TaskId taskId) {
    maybeInitBuilder();
    if (taskId == null) 
      builder.clearTaskId();
    this.taskId = taskId;
  }
  @Override
  public float getProgress() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    return (p.getProgress());
  }

  @Override
  public void setProgress(float progress) {
    maybeInitBuilder();
    builder.setProgress((progress));
  }
  @Override
  public TaskState getTaskState() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    if (!p.hasTaskState()) {
      return null;
    }
    return convertFromProtoFormat(p.getTaskState());
  }

  @Override
  public void setTaskState(TaskState taskState) {
    maybeInitBuilder();
    if (taskState == null) {
      builder.clearTaskState();
      return;
    }
    builder.setTaskState(convertToProtoFormat(taskState));
  }
  @Override
  public List<TaskAttemptId> getRunningAttemptsList() {
    initRunningAttempts();
    return this.runningAttempts;
  }
  @Override
  public TaskAttemptId getRunningAttempt(int index) {
    initRunningAttempts();
    return this.runningAttempts.get(index);
  }
  @Override
  public int getRunningAttemptsCount() {
    initRunningAttempts();
    return this.runningAttempts.size();
  }
  
  private void initRunningAttempts() {
    if (this.runningAttempts != null) {
      return;
    }
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    List<TaskAttemptIdProto> list = p.getRunningAttemptsList();
    this.runningAttempts = new ArrayList<TaskAttemptId>();

    for (TaskAttemptIdProto c : list) {
      this.runningAttempts.add(convertFromProtoFormat(c));
    }
  }
  
  @Override
  public void addAllRunningAttempts(final List<TaskAttemptId> runningAttempts) {
    if (runningAttempts == null)
      return;
    initRunningAttempts();
    this.runningAttempts.addAll(runningAttempts);
  }
  
  private void addRunningAttemptsToProto() {
    maybeInitBuilder();
    builder.clearRunningAttempts();
    if (runningAttempts == null)
      return;
    Iterable<TaskAttemptIdProto> iterable = new Iterable<TaskAttemptIdProto>() {
      @Override
      public Iterator<TaskAttemptIdProto> iterator() {
        return new Iterator<TaskAttemptIdProto>() {

          Iterator<TaskAttemptId> iter = runningAttempts.iterator();

          @Override
          public boolean hasNext() {
            return iter.hasNext();
          }

          @Override
          public TaskAttemptIdProto next() {
            return convertToProtoFormat(iter.next());
          }

          @Override
          public void remove() {
            throw new UnsupportedOperationException();

          }
        };

      }
    };
    builder.addAllRunningAttempts(iterable);
  }
  @Override
  public void addRunningAttempt(TaskAttemptId runningAttempts) {
    initRunningAttempts();
    this.runningAttempts.add(runningAttempts);
  }
  @Override
  public void removeRunningAttempt(int index) {
    initRunningAttempts();
    this.runningAttempts.remove(index);
  }
  @Override
  public void clearRunningAttempts() {
    initRunningAttempts();
    this.runningAttempts.clear();
  }
  @Override
  public TaskAttemptId getSuccessfulAttempt() {
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    if (this.successfulAttemptId != null) {
      return this.successfulAttemptId;
    }
    if (!p.hasSuccessfulAttempt()) {
      return null;
    }
    this.successfulAttemptId = convertFromProtoFormat(p.getSuccessfulAttempt());
    return this.successfulAttemptId;
  }

  @Override
  public void setSuccessfulAttempt(TaskAttemptId successfulAttempt) {
    maybeInitBuilder();
    if (successfulAttempt == null) 
      builder.clearSuccessfulAttempt();
    this.successfulAttemptId = successfulAttempt;
  }
  @Override
  public List<String> getDiagnosticsList() {
    initDiagnostics();
    return this.diagnostics;
  }
  @Override
  public String getDiagnostics(int index) {
    initDiagnostics();
    return this.diagnostics.get(index);
  }
  @Override
  public int getDiagnosticsCount() {
    initDiagnostics();
    return this.diagnostics.size();
  }
  
  private void initDiagnostics() {
    if (this.diagnostics != null) {
      return;
    }
    TaskReportProtoOrBuilder p = viaProto ? proto : builder;
    List<String> list = p.getDiagnosticsList();
    this.diagnostics = new ArrayList<String>();

    for (String c : list) {
      this.diagnostics.add(c);
    }
  }
  
  @Override
  public void addAllDiagnostics(final List<String> diagnostics) {
    if (diagnostics == null)
      return;
    initDiagnostics();
    this.diagnostics.addAll(diagnostics);
  }
  
  private void addDiagnosticsToProto() {
    maybeInitBuilder();
    builder.clearDiagnostics();
    if (diagnostics == null) 
      return;
    builder.addAllDiagnostics(diagnostics);
  }
  @Override
  public void addDiagnostics(String diagnostics) {
    initDiagnostics();
    this.diagnostics.add(diagnostics);
  }
  @Override
  public void removeDiagnostics(int index) {
    initDiagnostics();
    this.diagnostics.remove(index);
  }
  @Override
  public void clearDiagnostics() {
    initDiagnostics();
    this.diagnostics.clear();
  }

  private CountersPBImpl convertFromProtoFormat(CountersProto p) {
    return new CountersPBImpl(p);
  }

  private CountersProto convertToProtoFormat(Counters t) {
    return ((CountersPBImpl)t).getProto();
  }

  private TaskIdPBImpl convertFromProtoFormat(TaskIdProto p) {
    return new TaskIdPBImpl(p);
  }

  private TaskIdProto convertToProtoFormat(TaskId t) {
    return ((TaskIdPBImpl)t).getProto();
  }

  private TaskStateProto convertToProtoFormat(TaskState e) {
    return MRProtoUtils.convertToProtoFormat(e);
  }

  private TaskState convertFromProtoFormat(TaskStateProto e) {
    return MRProtoUtils.convertFromProtoFormat(e);
  }

  private TaskAttemptIdPBImpl convertFromProtoFormat(TaskAttemptIdProto p) {
    return new TaskAttemptIdPBImpl(p);
  }

  private TaskAttemptIdProto convertToProtoFormat(TaskAttemptId t) {
    return ((TaskAttemptIdPBImpl)t).getProto();
  }



}