/** Extract step data from model's cache container */
 @Nullable
 public TransientModelWithMetainfo retrieve(
     int majorStep, int minorStep, @NotNull SModelReference modelReference) {
   if (myCache == null) {
     return null;
   }
   // TODO if(myMinorStep >= stepCount) copy from current input model
   int stepsCount = myCache.getMinorCount(majorStep);
   myPerfTrace.push("Load intermediate cache", false);
   final TransientModelWithMetainfo rv =
       myCache.load(
           majorStep, minorStep >= stepsCount ? stepsCount - 1 : minorStep, modelReference);
   myPerfTrace.pop();
   return rv;
 }
 public void commit() {
   if (myCache == null) {
     return;
   }
   myPerfTrace.push("Save intermediate cache", false);
   myCache.store();
   myPerfTrace.pop();
 }
 // XXX TemplateGenerator has DependenciesBuilder, use it from there
 public void store(
     int majorStep, int minorStep, TemplateGenerator tg, DependenciesBuilder dependencyBuilder)
     throws GenerationFailureException {
   if (myCache == null) {
     return;
   }
   myPerfTrace.push("Save intermediate cache", false);
   final TransientModelWithMetainfo model =
       dependencyBuilder.create(tg.getOutputModel(), tg.getMappings());
   myCache.store(majorStep, minorStep, model);
   myPerfTrace.pop();
 }
  /** Load cache container for the model */
  public void loadExisting(@NotNull SModel model, @Nullable IncrementalReporter reporter) {
    myCache = null;
    GenerationDependencies dependencies = myIncrementalStrategy.getDependencies(model);
    if (dependencies == null || !dependencies.isContainsIncrementalInfo()) {
      return;
    }

    GenerationCacheContainer incrementalCacheContainer = myIncrementalStrategy.getContainer();
    if (incrementalCacheContainer == null) {
      if (reporter != null) {
        reporter.report("No container for incremental caches.");
      }
      return;
    }

    String oldHash = dependencies.getModelHash();
    ModelCacheContainer cacheContainer = incrementalCacheContainer.getCache(model, oldHash, false);
    if (cacheContainer == null) {
      if (reporter != null) {
        reporter.report("No cache for " + model.getReference().toString() + " (" + oldHash + ")");
      }
      return;
    }

    IntermediateModelsCache c = IntermediateModelsCache.load(cacheContainer);
    if (c != null && myPlanSignature.equals(c.getSignature())) {
      myCache = c;
    } else if (reporter != null) {
      if (c == null) {
        reporter.report("Caches are corrupted for " + oldHash);
      } else {
        reporter.report("Plan differs:");
        for (String s : DifflibFacade.getSimpleDiff(c.getSignature(), myPlanSignature)) {
          reporter.report(s);
        }
      }
    }
  }
 public void discard() {
   if (myCache != null) {
     myCache.remove();
   }
 }
 public boolean isStepCovered(int majorStep, int minorStep) {
   return myCache != null && minorStep < myCache.getMinorCount(majorStep);
 }