| // Copyright 2017 The Bazel Authors. All rights reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| package com.google.devtools.build.lib.vfs; | |
| import java.io.InvalidObjectException; | |
| import java.io.ObjectInputStream; | |
| /** | |
| * Abstract base class for {@link PathFragment} instances that will be allocated when Blaze is run | |
| * on a Windows platform. | |
| */ | |
| abstract class WindowsPathFragment extends PathFragment { | |
| static final Helper HELPER = new Helper(); | |
| protected final char driveLetter; | |
| protected WindowsPathFragment(char driveLetter, String[] segments) { | |
| super(segments); | |
| this.driveLetter = driveLetter; | |
| } | |
| @Override | |
| public String windowsVolume() { | |
| return (driveLetter != '\0') ? driveLetter + ":" : ""; | |
| } | |
| @Override | |
| public char getDriveLetter() { | |
| return driveLetter; | |
| } | |
| @Override | |
| protected int computeHashCode() { | |
| int h = 0; | |
| for (String segment : segments) { | |
| int segmentHash = segment.toLowerCase().hashCode(); | |
| h = h * 31 + segmentHash; | |
| } | |
| return h; | |
| } | |
| private static class Helper extends PathFragment.Helper { | |
| private static final char SEPARATOR_CHAR = '/'; | |
| // TODO(laszlocsomor): Lots of internal PathFragment operations, e.g. getPathString, use the | |
| // primary separator char and do not use this. | |
| private static final char EXTRA_SEPARATOR_CHAR = '\\'; | |
| @Override | |
| PathFragment create(String path) { | |
| // TODO(laszlocsomor): Character#isLetter returns true for some non ASCII characters. | |
| char driveLetter = | |
| path.length() >= 2 && path.charAt(1) == ':' && Character.isLetter(path.charAt(0)) | |
| ? Character.toUpperCase(path.charAt(0)) | |
| : '\0'; | |
| if (driveLetter != '\0') { | |
| path = path.substring(2); | |
| // TODO(bazel-team): Decide what to do about non-absolute paths with a volume name, e.g. | |
| // C:x. | |
| } | |
| boolean isAbsolute = path.length() > 0 && isSeparator(path.charAt(0)); | |
| return isAbsolute | |
| ? new AbsoluteWindowsPathFragment(driveLetter, segment(path, 1)) | |
| : new RelativeWindowsPathFragment(driveLetter, segment(path, 0)); | |
| } | |
| @Override | |
| PathFragment createAlreadyInterned(char driveLetter, boolean isAbsolute, String[] segments) { | |
| return isAbsolute | |
| ? new AbsoluteWindowsPathFragment(driveLetter, segments) | |
| : new RelativeWindowsPathFragment(driveLetter, segments); | |
| } | |
| @Override | |
| char getPrimarySeparatorChar() { | |
| return SEPARATOR_CHAR; | |
| } | |
| @Override | |
| boolean isSeparator(char c) { | |
| return c == SEPARATOR_CHAR || c == EXTRA_SEPARATOR_CHAR; | |
| } | |
| @Override | |
| boolean containsSeparatorChar(String path) { | |
| // TODO(laszlocsomor): This is inefficient. | |
| return path.indexOf(SEPARATOR_CHAR) != -1 || path.indexOf(EXTRA_SEPARATOR_CHAR) != -1; | |
| } | |
| @Override | |
| boolean segmentsEqual(int length, String[] segments1, int offset1, String[] segments2) { | |
| if ((segments1.length - offset1) < length || segments2.length < length) { | |
| return false; | |
| } | |
| for (int i = 0; i < length; ++i) { | |
| String seg1 = segments1[i + offset1]; | |
| String seg2 = segments2[i]; | |
| if ((seg1 == null) != (seg2 == null)) { | |
| return false; | |
| } | |
| if (seg1 == null) { | |
| continue; | |
| } | |
| // TODO(laszlocsomor): The calls to String#toLowerCase are inefficient and potentially | |
| // repeated too. Also, why not use String#equalsIgnoreCase. | |
| seg1 = seg1.toLowerCase(); | |
| seg2 = seg2.toLowerCase(); | |
| if (!seg1.equals(seg2)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| @Override | |
| protected int compare(PathFragment pathFragment1, PathFragment pathFragment2) { | |
| if (pathFragment1.isAbsolute() != pathFragment2.isAbsolute()) { | |
| return pathFragment1.isAbsolute() ? -1 : 1; | |
| } | |
| int cmp = Character.compare(pathFragment1.getDriveLetter(), pathFragment2.getDriveLetter()); | |
| if (cmp != 0) { | |
| return cmp; | |
| } | |
| String[] segments1 = pathFragment1.segments(); | |
| String[] segments2 = pathFragment2.segments(); | |
| int len1 = segments1.length; | |
| int len2 = segments2.length; | |
| int n = Math.min(len1, len2); | |
| for (int i = 0; i < n; i++) { | |
| String seg1 = segments1[i].toLowerCase(); | |
| String seg2 = segments2[i].toLowerCase(); | |
| cmp = seg1.compareTo(seg2); | |
| if (cmp != 0) { | |
| return cmp; | |
| } | |
| } | |
| return len1 - len2; | |
| } | |
| } | |
| private static final class AbsoluteWindowsPathFragment extends WindowsPathFragment { | |
| private AbsoluteWindowsPathFragment(char driveLetter, String[] segments) { | |
| super(driveLetter, segments); | |
| } | |
| @Override | |
| public boolean isAbsolute() { | |
| return true; | |
| } | |
| @Override | |
| protected int computeHashCode() { | |
| int h = Boolean.TRUE.hashCode(); | |
| h = h * 31 + super.computeHashCode(); | |
| h = h * 31 + Character.valueOf(getDriveLetter()).hashCode(); | |
| return h; | |
| } | |
| @Override | |
| public boolean equals(Object other) { | |
| if (!(other instanceof AbsoluteWindowsPathFragment)) { | |
| return false; | |
| } | |
| if (this == other) { | |
| return true; | |
| } | |
| AbsoluteWindowsPathFragment otherAbsoluteWindowsPathFragment = | |
| (AbsoluteWindowsPathFragment) other; | |
| return this.driveLetter == otherAbsoluteWindowsPathFragment.driveLetter | |
| && HELPER.segmentsEqual(this.segments, otherAbsoluteWindowsPathFragment.segments); | |
| } | |
| // Java serialization looks for the presence of this method in the concrete class. It is not | |
| // inherited from the parent class. | |
| @Override | |
| protected Object writeReplace() { | |
| return super.writeReplace(); | |
| } | |
| // Java serialization looks for the presence of this method in the concrete class. It is not | |
| // inherited from the parent class. | |
| @Override | |
| protected void readObject(ObjectInputStream stream) throws InvalidObjectException { | |
| super.readObject(stream); | |
| } | |
| } | |
| private static final class RelativeWindowsPathFragment extends WindowsPathFragment { | |
| private RelativeWindowsPathFragment(char driveLetter, String[] segments) { | |
| super(driveLetter, segments); | |
| } | |
| @Override | |
| public boolean isAbsolute() { | |
| return false; | |
| } | |
| @Override | |
| protected int computeHashCode() { | |
| int h = Boolean.FALSE.hashCode(); | |
| h = h * 31 + super.computeHashCode(); | |
| if (!isEmpty()) { | |
| h = h * 31 + Character.valueOf(getDriveLetter()).hashCode(); | |
| } | |
| return h; | |
| } | |
| @Override | |
| public boolean equals(Object other) { | |
| if (!(other instanceof RelativeWindowsPathFragment)) { | |
| return false; | |
| } | |
| if (this == other) { | |
| return true; | |
| } | |
| RelativeWindowsPathFragment otherRelativeWindowsPathFragment = | |
| (RelativeWindowsPathFragment) other; | |
| return isEmpty() && otherRelativeWindowsPathFragment.isEmpty() | |
| ? true | |
| : this.driveLetter == otherRelativeWindowsPathFragment.driveLetter | |
| && HELPER.segmentsEqual(this.segments, otherRelativeWindowsPathFragment.segments); | |
| } | |
| private boolean isEmpty() { | |
| return segmentCount() == 0; | |
| } | |
| // Java serialization looks for the presence of this method in the concrete class. It is not | |
| // inherited from the parent class. | |
| @Override | |
| protected Object writeReplace() { | |
| return super.writeReplace(); | |
| } | |
| // Java serialization looks for the presence of this method in the concrete class. It is not | |
| // inherited from the parent class. | |
| @Override | |
| protected void readObject(ObjectInputStream stream) throws InvalidObjectException { | |
| super.readObject(stream); | |
| } | |
| } | |
| } |