@Override public List<Issue> validate(final Resource resource, final CheckMode mode, final CancelIndicator mon) throws OperationCanceledError { final Provider<List<Issue>> _function = () -> { this.operationCanceledManager.checkCanceled(mon); return super.validate(resource, mode, mon); }; return this.cache.<List<Issue>>get(mode, resource, _function); }
private static Set<Pattern> doGetReferencedPatternsTransitively(final Pattern pattern, final Predicate<Pattern> filter) { if (pattern.eResource() == null) { Set<Pattern> patterns = new HashSet<>(); calculateReferencedPatternsTransitive(pattern, patterns, filter); return patterns; } else { Pair<Pattern, Predicate<Pattern>> key = new Pair<>(pattern, filter); return cache.get(key, pattern.eResource(), () -> calculateReferencedPatternsTransitive(pattern, filter)); } }
@Override /* @NonNull */ protected IResolvedTypes doResolveTypes(final /* @Nullable */ EObject object, final /* @Nullable */ CancelIndicator monitor) { // TODO: remove when we switch to an Xtend scope provider without artificial feature calls EObject nonArtificialObject = object; if(object.eResource() == null && object instanceof XAbstractFeatureCall) { nonArtificialObject = ((XAbstractFeatureCall) object).getFeature(); } // TODO final Resource resource = nonArtificialObject.eResource(); final LazyResolvedTypes result = cache.get(CachingBatchTypeResolver.class, resource, new Provider<LazyResolvedTypes>() { @Override public LazyResolvedTypes get() { final IReentrantTypeResolver resolver = delegate.getTypeResolver(object); return new LazyResolvedTypes(resolver, resource); } }); cache.execWithoutCacheClear(resource, new IUnitOfWork.Void<Resource>() { @Override public void process(Resource state) throws Exception { // trigger the actual resolution after the thing was cached result.resolveTypes(monitor == null ? CancelIndicator.NullImpl : monitor); } }); return result; }