Example usage for com.google.common.collect ImmutableSortedMap of

Introduction

In this page you can find the example usage for com.google.common.collect ImmutableSortedMap of.

Prototype

public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k1, V v1)

Source Link

Usage

From source file:com.palantir.lock.impl.LockServiceImpl.java

@Override
public boolean unlockSimple(SimpleHeldLocksToken token) {
    Preconditions.checkNotNull(token);//from  w  ww  .j a v  a2  s .c o  m
    LockDescriptor fakeLockDesc = StringLockDescriptor.of("unlockSimple");
    SortedLockCollection<LockDescriptor> fakeLockSet = LockCollections
            .of(ImmutableSortedMap.of(fakeLockDesc, LockMode.READ));
    return unlock(new HeldLocksToken(token.getTokenId(), LockClient.ANONYMOUS, token.getCreationDateMs(), 0L,
            fakeLockSet, maxAllowedLockTimeout, 0L));
}

From source file:com.palantir.lock.impl.LockServiceImpl.java

@Override
public Set<LockRefreshToken> refreshLockRefreshTokens(Iterable<LockRefreshToken> tokens) {
    List<HeldLocksToken> fakeTokens = Lists.newArrayList();
    LockDescriptor fakeLockDesc = StringLockDescriptor.of("refreshLockRefreshTokens");
    SortedLockCollection<LockDescriptor> fakeLockSet = LockCollections
            .of(ImmutableSortedMap.of(fakeLockDesc, LockMode.READ));
    for (LockRefreshToken token : tokens) {
        fakeTokens.add(new HeldLocksToken(token.getTokenId(), LockClient.ANONYMOUS, 0L, 0L, fakeLockSet,
                maxAllowedLockTimeout, 0L));
    }/*  w  ww  . j a v  a2s.  c o m*/
    return ImmutableSet
            .copyOf(Iterables.transform(refreshTokens(fakeTokens), HeldLocksTokens.getRefreshTokenFun()));
}

From source file:com.facebook.buck.features.apple.project.ProjectGenerator.java

private void createHeaderSymlinkTree(Map<Path, SourcePath> contents, ImmutableMap<Path, Path> nonSourcePaths,
        Optional<String> moduleName, Path headerSymlinkTreeRoot, boolean shouldCreateHeadersSymlinks,
        boolean shouldCreateHeaderMap, boolean shouldGenerateUmbrellaHeaderIfMissing) throws IOException {
    if (!shouldCreateHeaderMap && !shouldCreateHeadersSymlinks) {
        return;/*from   w w w .j  av  a2 s.c  om*/
    }
    LOG.verbose("Building header symlink tree at %s with contents %s", headerSymlinkTreeRoot, contents);
    ImmutableSortedMap.Builder<Path, Path> resolvedContentsBuilder = ImmutableSortedMap.naturalOrder();
    for (Map.Entry<Path, SourcePath> entry : contents.entrySet()) {
        Path link = headerSymlinkTreeRoot.resolve(entry.getKey());
        Path existing = projectFilesystem.resolve(resolveSourcePath(entry.getValue()));
        resolvedContentsBuilder.put(link, existing);
    }
    for (Map.Entry<Path, Path> entry : nonSourcePaths.entrySet()) {
        Path link = headerSymlinkTreeRoot.resolve(entry.getKey());
        resolvedContentsBuilder.put(link, entry.getValue());
    }
    ImmutableSortedMap<Path, Path> resolvedContents = resolvedContentsBuilder.build();

    Path headerMapLocation = getHeaderMapLocationFromSymlinkTreeRoot(headerSymlinkTreeRoot);

    Path hashCodeFilePath = headerSymlinkTreeRoot.resolve(".contents-hash");
    Optional<String> currentHashCode = projectFilesystem.readFileIfItExists(hashCodeFilePath);
    String newHashCode = getHeaderSymlinkTreeHashCode(resolvedContents, moduleName, shouldCreateHeadersSymlinks,
            shouldCreateHeaderMap).toString();
    if (Optional.of(newHashCode).equals(currentHashCode)) {
        LOG.debug("Symlink tree at %s is up to date, not regenerating (key %s).", headerSymlinkTreeRoot,
                newHashCode);
    } else {
        LOG.debug("Updating symlink tree at %s (old key %s, new key %s).", headerSymlinkTreeRoot,
                currentHashCode, newHashCode);
        projectFilesystem.deleteRecursivelyIfExists(headerSymlinkTreeRoot);
        projectFilesystem.mkdirs(headerSymlinkTreeRoot);
        if (shouldCreateHeadersSymlinks) {
            for (Map.Entry<Path, Path> entry : resolvedContents.entrySet()) {
                Path link = entry.getKey();
                Path existing = entry.getValue();
                projectFilesystem.createParentDirs(link);
                projectFilesystem.createSymLink(link, existing, /* force */ false);
            }
        }
        projectFilesystem.writeContentsToPath(newHashCode, hashCodeFilePath);

        if (shouldCreateHeaderMap) {
            HeaderMap.Builder headerMapBuilder = new HeaderMap.Builder();
            for (Map.Entry<Path, SourcePath> entry : contents.entrySet()) {
                if (shouldCreateHeadersSymlinks) {
                    headerMapBuilder.add(entry.getKey().toString(),
                            getHeaderMapRelativeSymlinkPathForEntry(entry, headerSymlinkTreeRoot));
                } else {
                    headerMapBuilder.add(entry.getKey().toString(),
                            projectFilesystem.resolve(resolveSourcePath(entry.getValue())));
                }
            }

            for (Map.Entry<Path, Path> entry : nonSourcePaths.entrySet()) {
                if (shouldCreateHeadersSymlinks) {
                    headerMapBuilder.add(entry.getKey().toString(),
                            getHeaderMapRelativeSymlinkPathForEntry(entry, headerSymlinkTreeRoot));
                } else {
                    headerMapBuilder.add(entry.getKey().toString(), entry.getValue());
                }
            }

            projectFilesystem.writeBytesToPath(headerMapBuilder.build().getBytes(), headerMapLocation);
        }
        if (moduleName.isPresent() && resolvedContents.size() > 0) {
            if (shouldGenerateUmbrellaHeaderIfMissing) {
                writeUmbrellaHeaderIfNeeded(moduleName.get(), resolvedContents.keySet(), headerSymlinkTreeRoot);
            }
            boolean containsSwift = !nonSourcePaths.isEmpty();
            if (containsSwift) {
                projectFilesystem.writeContentsToPath(
                        new ModuleMap(moduleName.get(), ModuleMap.SwiftMode.INCLUDE_SWIFT_HEADER).render(),
                        headerSymlinkTreeRoot.resolve(moduleName.get()).resolve("module.modulemap"));
                projectFilesystem.writeContentsToPath(
                        new ModuleMap(moduleName.get(), ModuleMap.SwiftMode.EXCLUDE_SWIFT_HEADER).render(),
                        headerSymlinkTreeRoot.resolve(moduleName.get()).resolve("objc.modulemap"));

                Path absoluteModuleRoot = projectFilesystem.getRootPath()
                        .resolve(headerSymlinkTreeRoot.resolve(moduleName.get()));
                VFSOverlay vfsOverlay = new VFSOverlay(
                        ImmutableSortedMap.of(absoluteModuleRoot.resolve("module.modulemap"),
                                absoluteModuleRoot.resolve("objc.modulemap")));

                projectFilesystem.writeContentsToPath(vfsOverlay.render(),
                        getObjcModulemapVFSOverlayLocationFromSymlinkTreeRoot(headerSymlinkTreeRoot));
            } else {
                projectFilesystem.writeContentsToPath(
                        new ModuleMap(moduleName.get(), ModuleMap.SwiftMode.NO_SWIFT).render(),
                        headerSymlinkTreeRoot.resolve(moduleName.get()).resolve("module.modulemap"));
            }
            Path absoluteModuleRoot = projectFilesystem.getRootPath()
                    .resolve(headerSymlinkTreeRoot.resolve(moduleName.get()));
            VFSOverlay vfsOverlay = new VFSOverlay(
                    ImmutableSortedMap.of(absoluteModuleRoot.resolve("module.modulemap"),
                            absoluteModuleRoot.resolve("testing.modulemap")));

            projectFilesystem.writeContentsToPath(vfsOverlay.render(),
                    getTestingModulemapVFSOverlayLocationFromSymlinkTreeRoot(headerSymlinkTreeRoot));
            projectFilesystem.writeContentsToPath("", // empty modulemap to allow non-modular imports for testing
                    headerSymlinkTreeRoot.resolve(moduleName.get()).resolve("testing.modulemap"));
        }
    }
    headerSymlinkTrees.add(headerSymlinkTreeRoot);
}