import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
private TLongObjectHashMap<ManualRangeMarker> getUpdatedMarkers(@NotNull FrozenDocument frozen, @NotNull List<DocumentEvent> events) {
  int eventCount = events.size();
  assert eventCount > 0;

  Trinity<Integer, TLongObjectHashMap<ManualRangeMarker>, FrozenDocument> cache = myUpdatedRanges;
  if (cache != null && cache.first.intValue() == eventCount) return cache.second;

  //noinspection SynchronizeOnThis
  synchronized (this) {
    cache = myUpdatedRanges;
    if (cache != null && cache.first.intValue() == eventCount) return cache.second;

    TLongObjectHashMap<ManualRangeMarker> answer;
    if (cache != null && cache.first < eventCount) {
      // apply only the new events
      answer = cache.second.clone();
      frozen = applyEvents(cache.third, events.subList(cache.first, eventCount), answer);
    }
    else {
      List<SelfElementInfo> infos = getInfos();
      answer = new TLongObjectHashMap<ManualRangeMarker>(infos.size());
      for (SelfElementInfo info : infos) {
        ProperTextRange range = info.getPsiRange();
        long key = info.markerCacheKey();
        if (range != null && key != 0) {
          boolean forInjected = info.isForInjected();
          answer.put(key, new ManualRangeMarker(frozen, range, forInjected, forInjected, !forInjected));
        }
      }
      frozen = applyEvents(frozen, events, answer);
    }

    myUpdatedRanges = Trinity.create(eventCount, answer, frozen);
    return answer;
  }
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
synchronized void updateMarkers(@NotNull FrozenDocument frozen, @NotNull List<DocumentEvent> events) {
  TLongObjectHashMap<ManualRangeMarker> updated = getUpdatedMarkers(frozen, events);

  for (SelfElementInfo info : getInfos()) {
    long key = info.markerCacheKey();
    if (key != 0) {
      ManualRangeMarker newRangeMarker = updated.get(key);
      info.setRange(newRangeMarker == null ? null : newRangeMarker.getRange());
    }
  }

  myUpdatedRanges = null;
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
public Multiplexer(@NotNull InputStream in, @NotNull OutputStream out, int mtu,
                   @NotNull ExecutorService executorService,
                   @Nullable NewChannelListener newChannelListener) {
  mDecoder = new Decoder(in);
  mEncoder = new Encoder(out);
  mNewChannelListener = newChannelListener;
  mChannelEventHandler = new ChannelEventHandler();
  mSender = new Sender(mtu, executorService);
  mChannelMap = new TLongObjectHashMap<Channel>();
  mNextChannelId = new AtomicLong(0);
  executorService.execute(new Receiver());
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
 * Clones the underlying trove collection and returns the clone wrapped in a new
 * decorator instance.  This is a shallow clone except where primitives are
 * concerned.
 *
 * @return a copy of the receiver
 */
public TLongObjectHashMapDecorator clone() {
    try {
        TLongObjectHashMapDecorator copy = (TLongObjectHashMapDecorator) super.clone();
        copy._map = (TLongObjectHashMap)_map.clone();
        return copy;
    } catch (CloneNotSupportedException e) {
        // assert(false);
        throw new InternalError(); // we are cloneable, so this does not happen
    }
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
public void readExternal(ObjectInput in)
    throws IOException, ClassNotFoundException {

    // VERSION
    in.readByte();

    // MAP
    _map = (TLongObjectHashMap<V>) in.readObject();
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
 * Create a new in memory string pool with 10 items by default.
 */
public MemoryStringPoolImpl() {

  nodeToStringPool = new TLongObjectHashMap<SPObject>(10);
  stringToNodePool = new TObjectLongHashMap<SPObject>(10);
  stringIndex = new TreeSet<SPObject>();

  // intialise the SPObject arrays
  smallestSPObjects = new SPObject[SPObject.TypeCategory.TCID_TYPED_LITERAL + 1];
  largestSPObjects = new SPObject[SPObject.TypeCategory.TCID_TYPED_LITERAL + 1];
  for (int s = 1; s <= SPObject.TypeCategory.TCID_TYPED_LITERAL; s++) {
    smallestSPObjects[s] = new SPLimit(s, true);
    largestSPObjects[s] = new SPLimit(s, false);
  }
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
 * Construct a resolver.
 *
 * @param resolverSession  the session this resolver is associated with,
 *   never <code>null</code>
 * @param rdfType  the local node representing the <code>rdf:type</code>
 *   property
 * @param modelTypeURI  the local node representing the model type managed
 *   by this class, never {@link NodePool#NONE}
 * @throws IllegalArgumentException  {@inheritDoc}, or if <var>modelType</var>
 *   is {@link NodePool#NONE}
 */
ViewResolver(ResolverSession resolverSession, Resolver systemResolver, long rdfType, long systemModel,
    long systemModelType, URI modelTypeURI, long viewNode,
    long typeNode, long exprNode, long modelNode, long unionNode, long intersectNode)
    throws ResolverFactoryException {

  // Validate "modelType" parameter
  if (modelTypeURI == null) {
    throw new IllegalArgumentException("Graph type can't be null");
  }
  this.resolverSession = resolverSession;
  this.systemResolver = systemResolver;
  this.modelTypeURI = modelTypeURI;
  this.viewNode = viewNode;
  this.typeNode = typeNode;
  this.exprNode = exprNode;
  this.modelNode = modelNode;
  this.unionNode = unionNode;
  this.intersectNode = intersectNode;
  this.viewCache = new TLongObjectHashMap<ViewDefinition>();
  try {
    Node systemModelTypeURIRef = resolverSession.globalize(systemModelType);
    if (systemModelTypeURIRef instanceof URIReference) {
      this.systemModelTypeURI = ((URIReference)systemModelTypeURIRef).getURI();
    } else {
      throw new ResolverFactoryException("systemModelType not a URIRef " + systemModelTypeURIRef);
    }
  } catch (GlobalizeException eg) {
    throw new ResolverFactoryException("Failed to globalize SystemModel Type", eg);
  }
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
 * Creates a wrapper that decorates the specified primitive map.
 */
public TLongObjectHashMapDecorator(TLongObjectHashMap<V> map) {
    super();
    this._map = map;
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
 * Returns a reference to the map wrapped by this decorator.
 */
public TLongObjectHashMap<V> getMap() {
    return _map;
}
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
    * Creates a wrapper that decorates the specified primitive map.
    */
   public TLongObjectHashMapDecorator(TLongObjectHashMap map) {
super();
this._map = map;
   }
 

import gnu.trove.TLongObjectHashMap; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param resolverSession The session in which the resolver exists
 * @param systemResolver The resolver used for the system model
 * @param rdfType The rdf:type predicate
 * @param systemModel The system model node id
 * @param systemModelType The system model's type node id
 * @param modelTypeURI The URI representing the file system's model type
 * @param fileSystemNode The node id for the file system model
 * @param includeNode The inclusion predicate node id
 * @param excludeNode The exclusion predicate node id
 *
 * @throws ResolverFactoryException
 */
FileSystemResolver(ResolverSession resolverSession, Resolver systemResolver,
                   long rdfType, long systemModel, long systemModelType,
                   URI modelTypeURI, long fileSystemNode, long includeNode,
                   long excludeNode) throws ResolverFactoryException {

  // Validate "modelType" parameter
  if (modelTypeURI == null) {

    throw new IllegalArgumentException("Graph type can't be null");
  }

  // Store the global variable values
  this.systemResolver = systemResolver;
  this.modelTypeURI = modelTypeURI;
  this.fileSystemNode = fileSystemNode;
  this.rdfType = rdfType;
  this.includeNode = includeNode;
  this.excludeNode = excludeNode;
  this.systemModel = systemModel;
  this.resolverSession = resolverSession;

  // Initialise the cache
  this.fileSystemCache = new TLongObjectHashMap<Resolution>();

  // Container for our system model's type node
  Node systemModelTypeURIRef = null;

  try {

    // Create an actual node for the system model type
    systemModelTypeURIRef = resolverSession.globalize(systemModelType);
  } catch (GlobalizeException globaliseException) {

    throw new ResolverFactoryException("Failed to globalize SystemModel " +
                                       "Type for file system model",
                                       globaliseException);
  }

  if (systemModelTypeURIRef instanceof URIReference) {

    // If we have a uri reference then store the system type's URI
    this.systemModelTypeURI = ((URIReference) systemModelTypeURIRef).getURI();
  } else {

    // We cannot handle literals for the system model
    throw new ResolverFactoryException("systemModelType not a URIRef " +
                                       systemModelTypeURIRef);
  }

  /**
   * Retrieves a transaction manager to help sequence resolution transactions.
   *
   * @return The transaction manager
   */
}