Java StoreTransaction类代码示例

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
private static void deleteLinks(StoreTransaction txn, Entity mainEntity) {
  Set<String> names = new HashSet<>(3);
  names.add(LINK_VARIABLE);
  names.add(LINK_FIELD_ACCESS);
  names.add(LINK_METHOD_CALL);

  // for (Entity entity : mainEntity.getLinks(LINK_REV_CLASS_REFERENCES)) {
  //   Entity classEntity = entity.getLink(LINK_CLASS);
  //   if (nonNull(classEntity)) {
  //     // reload
  //     classEntity.deleteLink(LINK_CLASS_REFERENCES, entity);
  //   }
  // }

  for (Entity entity : mainEntity.getLinks(names)) {
    entity.delete();
  }

  for (String name : names) {
    mainEntity.deleteLinks(name);
  }

  // mainEntity.deleteLinks(LINK_REV_CLASS_REFERENCES);
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
private static void addClassReference(
    StoreTransaction txn,
    Entity mainEntity,
    Map<String, ClassIndex> classIndex,
    Entity entity,
    String fqcn) {

  if (isNull(fqcn)) {
    return;
  }
  classIndex.computeIfPresent(
      fqcn,
      (key, index) -> {
        try {
          EntityId entityId = index.getEntityId();
          if (nonNull(entityId)) {
            Entity classEntity = txn.getEntity(entityId);
            classEntity.addLink(LINK_CLASS_REFERENCES, entity);

            entity.addLink(LINK_CLASS, classEntity);
            mainEntity.addLink(LINK_REV_CLASS_REFERENCES, entity);
          }
        } catch (Exception e) {
          log.warn(e.getMessage());
        }
        return index;
      });
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
@Override
public void store(StoreTransaction txn, Entity entity) {
  entity.setProperty("filePath", this.filePath);
  if (isNull(this.packageName)) {
    entity.setProperty("packageName", "");
  } else {
    entity.setProperty("packageName", this.packageName);
  }
  entity.setProperty("fqcn", this.getFQCN());
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
@Override
public void store(StoreTransaction txn, Entity entity) {
  entity.setProperty("declaration", this.declaration);
  entity.setProperty("name", this.name);
  if (isNull(this.filePath)) {
    // use test only
    entity.setProperty("filePath", "");
  } else {
    entity.setProperty("filePath", this.filePath);
  }
  entity.setProperty("isAnnotation", this.isAnnotation);
  entity.setProperty("isInterface", this.isInterface);
  entity.setProperty("functional", this.functional);
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
@Override
public void store(StoreTransaction txn, Entity entity) {
  entity.setProperty("name", name);
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
@Override
public void store(StoreTransaction txn, Entity entity) {

  long now = Instant.now().getEpochSecond();
  entity.setProperty("createdAt", now);
  entity.setProperty("result", this.success);
  entity.setProperty("problems", this.diagnostics.size());

  for (Diagnostic<? extends JavaFileObject> diagnostic : this.diagnostics) {
    String kind = diagnostic.getKind().toString();
    long line = diagnostic.getLineNumber();
    long column = diagnostic.getColumnNumber();

    String message = diagnostic.getMessage(null);
    if (isNull(message)) {
      message = "";
    }
    JavaFileObject fileObject = diagnostic.getSource();
    String path = null;
    if (fileObject != null) {
      final URI uri = fileObject.toUri();
      final File file = new File(uri);
      try {
        path = file.getCanonicalPath();
      } catch (IOException e) {
        throw new UncheckedIOException(e);
      }
    }

    String code = diagnostic.getCode();
    Entity subEntity = txn.newEntity(CompileResult.DIAGNOSTIC_ENTITY_TYPE);
    subEntity.setProperty("kind", kind);
    subEntity.setProperty("line", line);
    subEntity.setProperty("column", column);
    subEntity.setProperty("message", message);
    if (nonNull(path)) {
      subEntity.setProperty("path", path);
    }
    if (nonNull(code)) {
      subEntity.setProperty("code", code);
    }

    entity.addLink("diagnostic", entity);
  }
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
public <R> boolean execute(Function<StoreTransaction, Boolean> fn) {
  return this.entityStore.computeInTransaction(fn::apply);
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
public <R> R computeInReadonly(Function<StoreTransaction, R> fn) {
  return this.entityStore.computeInReadonlyTransaction(fn::apply);
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
private StoreTransaction getTransaction() {
	if(!collectingTransaction.isPresent()) 
		collectingTransaction = Optional.of(occStore.beginTransaction());
	return collectingTransaction.get();
}
 

import jetbrains.exodus.entitystore.StoreTransaction; //导入依赖的package包/类
void store(StoreTransaction txn, Entity mainEntity);