Examples with DirectorySnapshot org.gradle.internal.snapshot.DirectorySnapshot used on opensource projects

Example 1 with DirectorySnapshot

use of org.gradle.internal.snapshot.DirectorySnapshot in project gradle by gradle.

the class FileSystemSnapshotSerializer method write.

@Override
public void write(Encoder encoder, FileSystemSnapshot value) throws Exception {
    value.accept(new RootTrackingFileSystemSnapshotHierarchyVisitor() {

        @Override
        public void enterDirectory(DirectorySnapshot directorySnapshot, boolean isRoot) {
            try {
                writeEntryType(encoder, EntryType.DIR_OPEN);
                writePath(encoder, isRoot, directorySnapshot);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        @Override
        public SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, boolean isRoot) {
            snapshot.accept(new FileSystemLocationSnapshot.FileSystemLocationSnapshotVisitor() {

                @Override
                public void visitRegularFile(RegularFileSnapshot fileSnapshot) {
                    try {
                        writeEntryType(encoder, EntryType.REGULAR_FILE);
                        writePath(encoder, isRoot, fileSnapshot);
                        writeAccessType(encoder, fileSnapshot.getAccessType());
                        writeHashCode(encoder, fileSnapshot.getHash());
                        FileMetadata metadata = fileSnapshot.getMetadata();
                        encoder.writeSmallLong(metadata.getLastModified());
                        encoder.writeSmallLong(metadata.getLength());
                    } catch (IOException e) {
                        throw new UncheckedIOException(e);
                    }
                }

                @Override
                public void visitMissing(MissingFileSnapshot missingSnapshot) {
                    try {
                        writeEntryType(encoder, EntryType.MISSING);
                        writePath(encoder, isRoot, missingSnapshot);
                        writeAccessType(encoder, missingSnapshot.getAccessType());
                    } catch (IOException e) {
                        throw new UncheckedIOException(e);
                    }
                }
            });
            return SnapshotVisitResult.CONTINUE;
        }

        @Override
        public void leaveDirectory(DirectorySnapshot directorySnapshot, boolean isRoot) {
            try {
                writeEntryType(encoder, EntryType.DIR_CLOSE);
                writeAccessType(encoder, directorySnapshot.getAccessType());
                writeHashCode(encoder, directorySnapshot.getHash());
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
    });
    encoder.writeByte((byte) EntryType.END.ordinal());
}

Example 2 with DirectorySnapshot

use of org.gradle.internal.snapshot.DirectorySnapshot in project gradle by gradle.

the class FileSystemSnapshotSerializer method read.

@Override
public FileSystemSnapshot read(Decoder decoder) throws Exception {
    SnapshotStack stack = new SnapshotStack();
    stack.push();
    Deque<String> pathTracker = new ArrayDeque<>();
    while (true) {
        EntryType type = readEntryType(decoder);
        if (type == EntryType.END) {
            break;
        }
        if (type != EntryType.DIR_CLOSE) {
            String path = decoder.readString();
            String internedPath = stringInterner.intern(path);
            pathTracker.addLast(internedPath);
            if (type == EntryType.DIR_OPEN) {
                stack.push();
                continue;
            }
        }
        String internedAbsolutePath;
        String internedName;
        String path = pathTracker.removeLast();
        if (pathTracker.isEmpty()) {
            internedAbsolutePath = path;
            internedName = stringInterner.intern(PathUtil.getFileName(internedAbsolutePath));
        } else {
            internedAbsolutePath = stringInterner.intern(toAbsolutePath(pathTracker, path));
            internedName = path;
        }
        FileMetadata.AccessType accessType = readAccessType(decoder);
        switch(type) {
            case REGULAR_FILE:
                HashCode contentHash = readHashCode(decoder);
                long lastModified = decoder.readSmallLong();
                long length = decoder.readSmallLong();
                stack.add(new RegularFileSnapshot(internedAbsolutePath, internedName, contentHash, DefaultFileMetadata.file(lastModified, length, accessType)));
                break;
            case MISSING:
                stack.add(new MissingFileSnapshot(internedAbsolutePath, internedName, accessType));
                break;
            case DIR_CLOSE:
                HashCode merkleHash = readHashCode(decoder);
                List<FileSystemLocationSnapshot> children = stack.pop();
                stack.add(new DirectorySnapshot(internedAbsolutePath, internedName, accessType, merkleHash, children));
                break;
            default:
                throw new AssertionError();
        }
    }
    return CompositeFileSystemSnapshot.of(stack.pop());
}