import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@NotNull
public static ValidityState create(@NotNull final VirtualFile file,
                                   @NotNull final File compiledFile,
                                   final boolean isDebugMode,
                                   final boolean forceRecompilation) {
    final TimestampValidityState timestampValidityState = new TimestampValidityState(file.getTimeStamp());
    if (OCamlFileUtil.isOCamlFile(file)) {
        if (forceRecompilation || !compiledFile.exists()) {
            return NeedRecompilationValidityState.INSTANCE;
        }
        return new OCamlValidityState(timestampValidityState, isDebugMode);
    }
    else {
        return timestampValidityState;
    }
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public FileProcessingCompilerStateCache(File storeDirectory, final ValidityStateFactory stateFactory) throws IOException {
  myCache = new StateCache<MyState>(new File(storeDirectory, "timestamps")) {
    @Override
    public MyState read(DataInput stream) throws IOException {
      return new MyState(stream.readLong(), stateFactory.createValidityState(stream));
    }

    @Override
    public void write(MyState state, DataOutput out) throws IOException {
      out.writeLong(state.getTimestamp());
      final ValidityState extState = state.getExtState();
      if (extState != null) {
        extState.save(out);
      }
    }
  };
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public FileProcessingCompilerStateCache(File storeDirectory, final ValidityStateFactory stateFactory) throws IOException {
  myCache = new StateCache<MyState>(new File(storeDirectory, "timestamps")) {
    public MyState read(DataInput stream) throws IOException {
      return new MyState(stream.readLong(), stateFactory.createValidityState(stream));
    }

    public void write(MyState state, DataOutput out) throws IOException {
      out.writeLong(state.getTimestamp());
      final ValidityState extState = state.getExtState();
      if (extState != null) {
        extState.save(out);
      }
    }
  };
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@Override
public boolean equalsTo(ValidityState otherState) {
  if (!(otherState instanceof ResourceNamesValidityState)) {
    return false;
  }

  final ResourceNamesValidityState other = (ResourceNamesValidityState)otherState;

  return other.myAndroidTargetHashString.equals(myAndroidTargetHashString) &&
         other.myManifestTimestamp == myManifestTimestamp &&
         other.myResources.equals(myResources);
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@NotNull
protected OCamlLinkerProcessingItem createProcessingItem(@Nullable final OCamlModule ocamlModule,
                                                         @NotNull final VirtualFile file,
                                                         @NotNull final File compiledFile,
                                                         final boolean isDebugMode,
                                                         final boolean force) {
    final ValidityState state = OCamlValidityState.create(file, compiledFile, isDebugMode, force);
    return doCreateProcessingItem(ocamlModule, file, state);
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public boolean equalsTo(@Nullable final ValidityState otherState) {
    if (otherState == null || !(otherState instanceof OCamlValidityState)) {
      return false;
    }
    final OCamlValidityState thatState = (OCamlValidityState) otherState;
    return myTimestampValidityState.equalsTo(thatState.myTimestampValidityState) && myIsDebugMode == thatState.myIsDebugMode;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@Override
public boolean equalsTo(ValidityState validityState) {
    if (validityState instanceof CachedValidityState) {
        return stamp == ((CachedValidityState)validityState).stamp;
    }
    return false;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public boolean equalsTo(ValidityState otherState) {
  return otherState instanceof PsiElementsValidityState &&
         myDependencies.equals(((PsiElementsValidityState)otherState).myDependencies);
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public void update(VirtualFile sourceFile, ValidityState extState) throws IOException {
  if (sourceFile.isValid()) {
    // only mark as up-to-date if the file did not become invalid during make
    myCache.update(sourceFile.getUrl(), new MyState(sourceFile.getTimeStamp(), extState));
  }
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public ValidityState getExtState(String url) throws IOException {
  MyState state = myCache.getState(url);
  return (state != null)? state.getExtState() : null;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public MyState(long timestamp, @Nullable ValidityState extState) {
  myTimestamp = timestamp;
  myExtState = extState;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@Override
public boolean equalsTo(ValidityState otherState) {
  return otherState instanceof ClassesAndJarsValidityState
         && myFiles.equals(((ClassesAndJarsValidityState)otherState).myFiles);
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public ValidityState getValidityState() {
//        return new TimestampValidityState(myClassFile.getModificationStamp());
    return null;
  }
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@NotNull
private OCamlLinkerProcessingItem doCreateProcessingItem(@Nullable final OCamlModule ocamlModule,
                                                         @NotNull final VirtualFile file,
                                                         @Nullable final ValidityState state) {
    return new OCamlLinkerProcessingItem(ocamlModule, file, state);
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
private OCamlLinkerProcessingItem(@Nullable final OCamlModule OCamlModule, @NotNull final VirtualFile file, @Nullable final ValidityState state) {
    myOCamlModule = OCamlModule;
    myFile = file;
    myState = state;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@Nullable
public ValidityState getValidityState() {
    return myState;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@NotNull
public ValidityState createValidityState(@NotNull final DataInput in) throws IOException {
    return OCamlValidityState.load(in);
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
@Override
public ValidityState getValidityState() {
    return new CachedValidityState(file.getModificationStamp());
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public ValidityState createValidityState(DataInput in) throws IOException {
  return null;
}
 

import com.intellij.openapi.compiler.ValidityState; //导入依赖的package包/类
public ValidityState getValidityState() {
  return null;
}