blob: 0df5ce05ae85257bbf96471396802c7723685194 [file] [log] [blame]
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:collection';
/**
* Implementation of [Uri] that understands only a limited set of valid
* URI formats, but works fast. In practice Dart code almost always uses such
* limited URI format, so almost always can be processed fast.
*/
class FastUri implements Uri {
/***
* The maximum [_cache] length before we flush it and start a new generation.
*/
static const int _MAX_CACHE_LENGTH_BEFORE_FLUSH = 50000;
static HashMap<String, Uri> _cache = new HashMap<String, Uri>();
static int _currentCacheLength = 0;
static int _currentCacheGeneration = 0;
final int _cacheGeneration;
final String _text;
final String _scheme;
final bool _hasEmptyAuthority;
final String _path;
/**
* The offset of the last `/` in [_text], or `null` if there isn't any.
*/
final int _lastSlashIndex;
/**
* The cached hashcode.
*/
int _hashCode;
Uri _cachedFallbackUri;
FastUri._(this._cacheGeneration, this._text, this._scheme,
this._hasEmptyAuthority, this._path, this._lastSlashIndex);
@override
String get authority => '';
@override
UriData get data => null;
@override
String get fragment => '';
@override
bool get hasAbsolutePath => path.startsWith('/');
@override
bool get hasAuthority => _hasEmptyAuthority;
@override
bool get hasEmptyPath => _path.isEmpty;
@override
bool get hasFragment => false;
@override
int get hashCode => _text.hashCode;
@override
bool get hasPort => false;
@override
bool get hasQuery => false;
@override
bool get hasScheme => _scheme.isNotEmpty;
@override
String get host => '';
@override
bool get isAbsolute => hasScheme;
@override
String get origin => _fallbackUri.origin;
@override
String get path => _path;
@override
List<String> get pathSegments => _fallbackUri.pathSegments;
@override
int get port => 0;
@override
String get query => '';
@override
Map<String, String> get queryParameters => const <String, String>{};
@override
Map<String, List<String>> get queryParametersAll =>
const <String, List<String>>{};
@override
String get scheme => _scheme;
@override
String get userInfo => '';
/**
* Full [Uri] object computed on demand; we fall back to this for some of the
* more complex methods of [Uri] that are less in need of a fast
* implementation.
*/
Uri get _fallbackUri => _cachedFallbackUri ??= Uri.parse(_text);
@override
bool operator ==(other) {
if (other is FastUri) {
if (other._cacheGeneration == _cacheGeneration) {
return identical(other, this);
}
return _text == other._text;
} else if (other is Uri) {
return _fallbackUri == other;
}
return false;
}
@override
Uri normalizePath() {
return this;
}
@override
Uri removeFragment() {
return this;
}
@override
Uri replace(
{String scheme,
String userInfo,
String host,
int port,
String path,
Iterable<String> pathSegments,
String query,
Map<String, dynamic> queryParameters,
String fragment}) {
return _fallbackUri.replace(
scheme: scheme,
userInfo: userInfo,
host: host,
port: port,
path: path,
pathSegments: pathSegments,
query: query,
queryParameters: queryParameters,
fragment: fragment);
}
@override
Uri resolve(String reference) {
// TODO: maybe implement faster
return _fallbackUri.resolve(reference);
}
@override
Uri resolveUri(Uri reference) {
if (reference.hasScheme) {
return reference;
}
String refPath = reference.path;
if (refPath.startsWith('./')) {
refPath = refPath.substring(2);
}
if (refPath.startsWith('../') ||
refPath.contains('/../') ||
refPath.contains('/./')) {
Uri slowResult = _fallbackUri.resolveUri(reference);
return FastUri.parse(slowResult.toString());
}
String newText;
if (_lastSlashIndex != null) {
newText = _text.substring(0, _lastSlashIndex + 1) + refPath;
} else {
newText = _text + '/' + refPath;
}
return FastUri.parse(newText);
}
@override
String toFilePath({bool windows}) {
return _fallbackUri.toFilePath(windows: windows);
}
@override
String toString() => _text;
/**
* Parse the given URI [text] and return the corresponding [Uri] instance. If
* the [text] can be represented as a [FastUri], then it is returned. If the
* [text] is more complex, then `dart:core` [Uri] is created and returned.
* This method also performs memoization, so that usually the same instance
* of [FastUri] or [Uri] is returned for the same [text].
*/
static Uri parse(String text) {
Uri uri = _cache[text];
if (uri == null) {
uri = _parse(text);
uri ??= Uri.parse(text);
_cache[text] = uri;
_currentCacheLength++;
// If the cache is too big, start a new generation.
if (_currentCacheLength > _MAX_CACHE_LENGTH_BEFORE_FLUSH) {
_cache.clear();
_currentCacheLength = 0;
_currentCacheGeneration++;
}
}
return uri;
}
static bool _isAlphabetic(int char) {
return char >= 'A'.codeUnitAt(0) && char <= 'Z'.codeUnitAt(0) ||
char >= 'a'.codeUnitAt(0) && char <= 'z'.codeUnitAt(0);
}
static bool _isDigit(int char) {
return char >= '0'.codeUnitAt(0) && char <= '9'.codeUnitAt(0);
}
/**
* Parse the given [text] into a new [FastUri]. If the [text] uses URI
* features that are not supported by [FastUri], return `null`.
*/
static FastUri _parse(String text) {
int schemeEnd = null;
int pathStart = 0;
int lastSlashIndex = null;
for (int i = 0; i < text.length; i++) {
int char = text.codeUnitAt(i);
if (_isAlphabetic(char) ||
_isDigit(char) ||
char == '.'.codeUnitAt(0) ||
char == '-'.codeUnitAt(0) ||
char == '_'.codeUnitAt(0)) {
// Valid characters.
} else if (char == '/'.codeUnitAt(0)) {
lastSlashIndex = i;
} else if (char == ':'.codeUnitAt(0)) {
if (schemeEnd != null) {
return null;
}
schemeEnd = i;
pathStart = i + 1;
} else {
return null;
}
}
String scheme = schemeEnd != null ? text.substring(0, schemeEnd) : '';
bool hasEmptyAuthority = false;
String path = text.substring(pathStart);
if (path.startsWith('//')) {
hasEmptyAuthority = true;
path = path.substring(2);
if (!path.startsWith('/')) {
return null;
}
}
return new FastUri._(_currentCacheGeneration, text, scheme,
hasEmptyAuthority, path, lastSlashIndex);
}
}