ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add assert messages for all assertions up until ol.renderer.vector.

Browse Source
This commit is contained in:
Bart van den Eijnden
2015-03-30 16:41:32 +02:00
parent fb9ba22c30
commit 47ce127a10
74 changed files with 1173 additions and 682 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ol/array.js
View File

@@ -92,8 +92,10 @@ ol.array.linearFindNearest = function(arr, target, direction) {
* @param {number} end End index.
*/
ol.array.reverseSubArray = function(arr, begin, end) {
goog.asserts.assert(begin >= 0);
goog.asserts.assert(end < arr.length);
goog.asserts.assert(begin >= 0,
'Array begin index should be equal to or greater than 0');
goog.asserts.assert(end < arr.length,
'Array end index should be less than the array length');
while (begin < end) {
var tmp = arr[begin];
arr[begin] = arr[end];

13
src/ol/binary.js
View File

@@ -42,14 +42,15 @@ ol.binary.Buffer.prototype.getReader = function() {
uint8View[i] = data.charCodeAt(i);
}
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown data type, should be string or ArrayBuffer');
return null;
}
return new ol.binary.ArrayBufferReader(arrayBuffer);
} else {
goog.asserts.assert(goog.isString(data));
goog.asserts.assert(goog.isString(data), 'Data should be a string');
goog.asserts.assert(
goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('10.0'));
goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('10.0'),
'In IE10 and above ArrayBuffer should be used instead');
return new ol.binary.ArrayReader(new VBArray(data).toArray());
}
};
@@ -118,7 +119,8 @@ ol.binary.ArrayBufferReader.prototype.readByte = function() {
if (this.offset_ < this.length_) {
return this.uint8View_[this.offset_++];
} else {
goog.asserts.fail();
goog.asserts.fail(
'readByte fails because offset is larger than or equal to length');
return 0;
}
};
@@ -168,7 +170,8 @@ ol.binary.ArrayReader.prototype.readByte = function() {
if (this.offset_ < this.length_) {
return this.array_[this.offset_++];
} else {
goog.asserts.fail();
goog.asserts.fail(
'readByte fails because offset is larger than or equal to length');
return 0;
}
};

15
src/ol/color/color.js
View File

@@ -88,7 +88,8 @@ ol.color.blend = function(dst, src, opt_color) {
out[3] = outA;
}
}
goog.asserts.assert(ol.color.isValid(out));
goog.asserts.assert(ol.color.isValid(out),
'Output color of blend should be a valid color');
return out;
};
@@ -104,7 +105,7 @@ ol.color.asArray = function(color) {
if (goog.isArray(color)) {
return color;
} else {
goog.asserts.assert(goog.isString(color));
goog.asserts.assert(goog.isString(color), 'Color should be a string');
return ol.color.fromString(color);
}
};
@@ -120,7 +121,7 @@ ol.color.asString = function(color) {
if (goog.isString(color)) {
return color;
} else {
goog.asserts.assert(goog.isArray(color));
goog.asserts.assert(goog.isArray(color), 'Color should be an array');
return ol.color.toString(color);
}
};
@@ -215,7 +216,8 @@ ol.color.fromStringInternal_ = function(s) {
var r, g, b, a, color, match;
if (isHex || (match = ol.color.hexColorRe_.exec(s))) { // hex
var n = s.length - 1; // number of hex digits
goog.asserts.assert(n == 3 || n == 6);
goog.asserts.assert(n == 3 || n == 6,
'Color string length should be 3 or 6');
var d = n == 3 ? 1 : 2; // number of digits per channel
r = parseInt(s.substr(1 + 0 * d, d), 16);
g = parseInt(s.substr(1 + 1 * d, d), 16);
@@ -227,7 +229,8 @@ ol.color.fromStringInternal_ = function(s) {
}
a = 1;
color = [r, g, b, a];
goog.asserts.assert(ol.color.isValid(color));
goog.asserts.assert(ol.color.isValid(color),
'Color should be a valid color');
return color;
} else if ((match = ol.color.rgbaColorRe_.exec(s))) { // rgba()
r = Number(match[1]);
@@ -307,7 +310,7 @@ ol.color.toString = function(color) {
ol.color.transform = function(color, transform, opt_color) {
var result = goog.isDef(opt_color) ? opt_color : [];
result = goog.vec.Mat4.multVec3(transform, color, result);
goog.asserts.assert(goog.isArray(result));
goog.asserts.assert(goog.isArray(result), 'result should be an array');
result[3] = color[3];
return ol.color.normalize(result, result);
};

7
src/ol/control/attributioncontrol.js
View File

@@ -167,7 +167,7 @@ ol.control.Attribution.prototype.getSourceAttributions = function(frameState) {
/** @type {Object.<string, ol.Attribution>} */
var hiddenAttributions = {};
var projection = frameState.viewState.projection;
goog.asserts.assert(!goog.isNull(projection));
goog.asserts.assert(!goog.isNull(projection), 'projection cannot be null');
for (i = 0, ii = layerStatesArray.length; i < ii; i++) {
source = layerStatesArray[i].layer.getSource();
if (goog.isNull(source)) {
@@ -186,9 +186,10 @@ ol.control.Attribution.prototype.getSourceAttributions = function(frameState) {
}
tileRanges = frameState.usedTiles[sourceKey];
if (goog.isDef(tileRanges)) {
goog.asserts.assertInstanceof(source, ol.source.Tile);
goog.asserts.assertInstanceof(source, ol.source.Tile,
'source should be an ol.source.Tile');
var tileGrid = source.getTileGridForProjection(projection);
goog.asserts.assert(!goog.isNull(tileGrid));
goog.asserts.assert(!goog.isNull(tileGrid), 'tileGrid cannot be null');
intersectsTileRange = sourceAttribution.intersectsAnyTileRange(
tileRanges, tileGrid, projection);
} else {

6
src/ol/control/fullscreencontrol.js
View File

@@ -123,9 +123,11 @@ ol.control.FullScreen.prototype.handleFullScreen_ = function() {
goog.dom.fullscreen.exitFullScreen();
} else {
var target = map.getTarget();
goog.asserts.assert(goog.isDefAndNotNull(target));
goog.asserts.assert(goog.isDefAndNotNull(target),
'target should be defined');
var element = goog.dom.getElement(target);
goog.asserts.assert(goog.isDefAndNotNull(element));
goog.asserts.assert(goog.isDefAndNotNull(element),
'element should be defined');
if (this.keys_) {
goog.dom.fullscreen.requestFullScreenWithKeys(element);
} else {

32
src/ol/control/overviewmapcontrol.js
View File

@@ -247,17 +247,17 @@ ol.control.OverviewMap.prototype.validateExtent_ = function() {
}
var mapSize = map.getSize();
goog.asserts.assertArray(mapSize);
goog.asserts.assertArray(mapSize, 'mapSize should be an array');
var view = map.getView();
goog.asserts.assert(goog.isDef(view));
goog.asserts.assert(goog.isDef(view), 'view should be defined');
var extent = view.calculateExtent(mapSize);
var ovmapSize = ovmap.getSize();
goog.asserts.assertArray(ovmapSize);
goog.asserts.assertArray(ovmapSize, 'ovmapSize should be an array');
var ovview = ovmap.getView();
goog.asserts.assert(goog.isDef(ovview));
goog.asserts.assert(goog.isDef(ovview), 'ovview should be defined');
var ovextent = ovview.calculateExtent(ovmapSize);
var topLeftPixel =
@@ -296,17 +296,17 @@ ol.control.OverviewMap.prototype.resetExtent_ = function() {
var ovmap = this.ovmap_;
var mapSize = map.getSize();
goog.asserts.assertArray(mapSize);
goog.asserts.assertArray(mapSize, 'mapSize should be an array');
var view = map.getView();
goog.asserts.assert(goog.isDef(view));
goog.asserts.assert(goog.isDef(view), 'view should be defined');
var extent = view.calculateExtent(mapSize);
var ovmapSize = ovmap.getSize();
goog.asserts.assertArray(ovmapSize);
goog.asserts.assertArray(ovmapSize, 'ovmapSize should be an array');
var ovview = ovmap.getView();
goog.asserts.assert(goog.isDef(ovview));
goog.asserts.assert(goog.isDef(ovview), 'ovview should be defined');
// get how many times the current map overview could hold different
// box sizes using the min and max ratio, pick the step in the middle used
@@ -329,10 +329,10 @@ ol.control.OverviewMap.prototype.recenter_ = function() {
var ovmap = this.ovmap_;
var view = map.getView();
goog.asserts.assert(goog.isDef(view));
goog.asserts.assert(goog.isDef(view), 'view should be defined');
var ovview = ovmap.getView();
goog.asserts.assert(goog.isDef(ovview));
goog.asserts.assert(goog.isDef(ovview), 'ovview should be defined');
ovview.setCenter(view.getCenter());
};
@@ -351,19 +351,19 @@ ol.control.OverviewMap.prototype.updateBox_ = function() {
}
var mapSize = map.getSize();
goog.asserts.assertArray(mapSize);
goog.asserts.assertArray(mapSize, 'mapSize should be an array');
var view = map.getView();
goog.asserts.assert(goog.isDef(view));
goog.asserts.assert(goog.isDef(view), 'view should be defined');
var ovview = ovmap.getView();
goog.asserts.assert(goog.isDef(ovview));
goog.asserts.assert(goog.isDef(ovview), 'ovview should be defined');
var ovmapSize = ovmap.getSize();
goog.asserts.assertArray(ovmapSize);
goog.asserts.assertArray(ovmapSize, 'ovmapSize should be an array');
var rotation = view.getRotation();
goog.asserts.assert(goog.isDef(rotation));
goog.asserts.assert(goog.isDef(rotation), 'rotation should be defined');
var overlay = this.boxOverlay_;
var box = this.boxOverlay_.getElement();
@@ -398,7 +398,7 @@ ol.control.OverviewMap.prototype.calculateCoordinateRotate_ = function(
var map = this.getMap();
var view = map.getView();
goog.asserts.assert(goog.isDef(view));
goog.asserts.assert(goog.isDef(view), 'view should be defined');
var currentCenter = view.getCenter();

8
src/ol/control/scalelinecontrol.js
View File

@@ -238,7 +238,8 @@ ol.control.ScaleLine.prototype.updateElement_ = function() {
}
cosLatitude = Math.cos(goog.math.toRadians(this.toEPSG4326_(center)[1]));
var radius = ol.sphere.NORMAL.radius;
goog.asserts.assert(goog.isDef(ol.proj.METERS_PER_UNIT[projectionUnits]));
goog.asserts.assert(goog.isDef(ol.proj.METERS_PER_UNIT[projectionUnits]),
'Meters per unit should be defined for the projection unit');
radius /= ol.proj.METERS_PER_UNIT[projectionUnits];
pointResolution *= 180 / (Math.PI * cosLatitude * radius);
projectionUnits = ol.proj.Units.DEGREES;
@@ -254,7 +255,8 @@ ol.control.ScaleLine.prototype.updateElement_ = function() {
units == ol.control.ScaleLineUnits.NAUTICAL) &&
projectionUnits == ol.proj.Units.METERS) ||
(units == ol.control.ScaleLineUnits.DEGREES &&
projectionUnits == ol.proj.Units.DEGREES));
projectionUnits == ol.proj.Units.DEGREES),
'Scale line units and projection units should match');
var nominalCount = this.minWidth_ * pointResolution;
var suffix = '';
@@ -304,7 +306,7 @@ ol.control.ScaleLine.prototype.updateElement_ = function() {
pointResolution /= 1609.3472;
}
} else {
goog.asserts.fail();
goog.asserts.fail('Scale line element cannot be updated');
}
var i = 3 * Math.floor(

9
src/ol/control/zoomslidercontrol.js
View File

@@ -178,7 +178,8 @@ ol.control.ZoomSlider.render = function(mapEvent) {
if (goog.isNull(mapEvent.frameState)) {
return;
}
goog.asserts.assert(goog.isDefAndNotNull(mapEvent.frameState.viewState));
goog.asserts.assert(goog.isDefAndNotNull(mapEvent.frameState.viewState),
'viewState should be defined');
if (!this.sliderInitialized_) {
this.initSlider_();
}
@@ -198,7 +199,8 @@ ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) {
var map = this.getMap();
var view = map.getView();
var currentResolution = view.getResolution();
goog.asserts.assert(goog.isDef(currentResolution));
goog.asserts.assert(goog.isDef(currentResolution),
'currentResolution should be defined');
map.beforeRender(ol.animation.zoom({
resolution: currentResolution,
duration: ol.ZOOMSLIDER_ANIMATION_DURATION,
@@ -244,7 +246,8 @@ ol.control.ZoomSlider.prototype.handleDraggerEnd_ = function(event) {
var map = this.getMap();
var view = map.getView();
view.setHint(ol.ViewHint.INTERACTING, -1);
goog.asserts.assert(goog.isDef(this.currentResolution_));
goog.asserts.assert(goog.isDef(this.currentResolution_),
'this.currentResolution_ should be defined');
map.beforeRender(ol.animation.zoom({
resolution: this.currentResolution_,
duration: ol.ZOOMSLIDER_ANIMATION_DURATION,

2
src/ol/control/zoomtoextentcontrol.js
View File

@@ -81,6 +81,6 @@ ol.control.ZoomToExtent.prototype.handleZoomToExtent_ = function() {
var extent = goog.isNull(this.extent_) ?
view.getProjection().getExtent() : this.extent_;
var size = map.getSize();
goog.asserts.assert(goog.isDef(size));
goog.asserts.assert(goog.isDef(size), 'size should be defined');
view.fitExtent(extent, size);
};

6
src/ol/dom/dom.js
View File

@@ -48,7 +48,8 @@ ol.dom.canUseCssTransform = (function() {
var canUseCssTransform;
return function() {
if (!goog.isDef(canUseCssTransform)) {
goog.asserts.assert(!goog.isNull(document.body));
goog.asserts.assert(!goog.isNull(document.body),
'document.body should not be null');
if (!goog.global.getComputedStyle) {
// this browser is ancient
canUseCssTransform = false;
@@ -90,7 +91,8 @@ ol.dom.canUseCssTransform3D = (function() {
var canUseCssTransform3D;
return function() {
if (!goog.isDef(canUseCssTransform3D)) {
goog.asserts.assert(!goog.isNull(document.body));
goog.asserts.assert(!goog.isNull(document.body),
'document.body should not be null');
if (!goog.global.getComputedStyle) {
// this browser is ancient
canUseCssTransform3D = false;

3
src/ol/dom/input.js
View File

@@ -120,7 +120,8 @@ goog.exportProperty(
* @private
*/
ol.dom.Input.prototype.handleInputChanged_ = function(browserEvent) {
goog.asserts.assert(browserEvent.currentTarget == this.target_);
goog.asserts.assert(browserEvent.currentTarget == this.target_,
'currentTarget should be the same as this.target_');
var target = this.target_;
if (target.type === 'checkbox' || target.type === 'radio') {
this.setChecked(target.checked);

6
src/ol/events/condition.js
View File

@@ -145,7 +145,8 @@ ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) {
*/
ol.events.condition.targetNotEditable = function(mapBrowserEvent) {
var target = mapBrowserEvent.browserEvent.target;
goog.asserts.assertInstanceof(target, Element);
goog.asserts.assertInstanceof(target, Element,
'target should be an Element');
var tagName = target.tagName;
return (
tagName !== goog.dom.TagName.INPUT &&
@@ -160,7 +161,8 @@ ol.events.condition.targetNotEditable = function(mapBrowserEvent) {
* @api stable
*/
ol.events.condition.mouseOnly = function(mapBrowserEvent) {
goog.asserts.assertInstanceof(mapBrowserEvent, ol.MapBrowserPointerEvent);
goog.asserts.assertInstanceof(mapBrowserEvent, ol.MapBrowserPointerEvent,
'mapBrowserEvent should be an instance of ol.MapBrowserPointerEvent');
/* pointerId must be 1 for mouse devices,
* see: http://www.w3.org/Submission/pointer-events/#pointerevent-interface
*/

6
src/ol/extent.js
View File

@@ -68,8 +68,8 @@ ol.extent.boundingExtent = function(coordinates) {
* @return {ol.Extent} Extent.
*/
ol.extent.boundingExtentXYs_ = function(xs, ys, opt_extent) {
goog.asserts.assert(xs.length > 0);
goog.asserts.assert(ys.length > 0);
goog.asserts.assert(xs.length > 0, 'xs length should be larger than 0');
goog.asserts.assert(ys.length > 0, 'ys length should be larger than 0');
var minX = Math.min.apply(null, xs);
var minY = Math.min.apply(null, ys);
var maxX = Math.max.apply(null, xs);
@@ -533,7 +533,7 @@ ol.extent.getCorner = function(extent, corner) {
} else {
goog.asserts.fail('Invalid corner: %s', corner);
}
goog.asserts.assert(goog.isDef(coordinate));
goog.asserts.assert(goog.isDef(coordinate), 'coordinate should be defined');
return coordinate;
};

6
src/ol/feature.js
View File

@@ -104,7 +104,8 @@ ol.Feature = function(opt_geometryOrProperties) {
var geometry = /** @type {ol.geom.Geometry} */ (opt_geometryOrProperties);
this.setGeometry(geometry);
} else {
goog.asserts.assert(goog.isObject(opt_geometryOrProperties));
goog.asserts.assert(goog.isObject(opt_geometryOrProperties),
'opt_geometryOrProperties should be an Object');
var properties = /** @type {Object.<string, *>} */
(opt_geometryOrProperties);
this.setProperties(properties);
@@ -320,7 +321,8 @@ ol.feature.createFeatureStyleFunction = function(obj) {
if (goog.isArray(obj)) {
styles = obj;
} else {
goog.asserts.assertInstanceof(obj, ol.style.Style);
goog.asserts.assertInstanceof(obj, ol.style.Style,
'obj should be an ol.style.Style');
styles = [obj];
}
styleFunction = goog.functions.constant(styles);

12
src/ol/featureoverlay.js
View File

@@ -80,7 +80,8 @@ ol.FeatureOverlay = function(opt_options) {
if (goog.isArray(options.features)) {
this.setFeatures(new ol.Collection(options.features.slice()));
} else {
goog.asserts.assertInstanceof(options.features, ol.Collection);
goog.asserts.assertInstanceof(options.features, ol.Collection,
'options.features should be an ol.Collection');
this.setFeatures(options.features);
}
} else {
@@ -134,7 +135,8 @@ ol.FeatureOverlay.prototype.handleFeatureChange_ = function() {
* @param {ol.CollectionEvent} collectionEvent Collection event.
*/
ol.FeatureOverlay.prototype.handleFeaturesAdd_ = function(collectionEvent) {
goog.asserts.assert(!goog.isNull(this.featureChangeListenerKeys_));
goog.asserts.assert(!goog.isNull(this.featureChangeListenerKeys_),
'this.featureChangeListenerKeys_ should not be null');
var feature = /** @type {ol.Feature} */ (collectionEvent.element);
this.featureChangeListenerKeys_[goog.getUid(feature).toString()] =
goog.events.listen(feature, goog.events.EventType.CHANGE,
@@ -148,7 +150,8 @@ ol.FeatureOverlay.prototype.handleFeaturesAdd_ = function(collectionEvent) {
* @param {ol.CollectionEvent} collectionEvent Collection event.
*/
ol.FeatureOverlay.prototype.handleFeaturesRemove_ = function(collectionEvent) {
goog.asserts.assert(!goog.isNull(this.featureChangeListenerKeys_));
goog.asserts.assert(!goog.isNull(this.featureChangeListenerKeys_),
'this.featureChangeListenerKeys_ should not be null');
var feature = /** @type {ol.Feature} */ (collectionEvent.element);
var key = goog.getUid(feature).toString();
goog.events.unlistenByKey(this.featureChangeListenerKeys_[key]);
@@ -181,7 +184,8 @@ ol.FeatureOverlay.prototype.handleMapPostCompose_ = function(event) {
}
var replayGroup = /** @type {ol.render.IReplayGroup} */
(event.replayGroup);
goog.asserts.assert(goog.isDef(replayGroup));
goog.asserts.assert(goog.isDef(replayGroup),
'replayGroup should be defined');
var frameState = event.frameState;
var pixelRatio = frameState.pixelRatio;
var resolution = frameState.viewState.resolution;

58
src/ol/format/geojsonformat.js
View File

@@ -10,7 +10,6 @@ goog.require('ol.Feature');
goog.require('ol.format.Feature');
goog.require('ol.format.JSONFeature');
goog.require('ol.geom.GeometryCollection');
goog.require('ol.geom.GeometryType');
goog.require('ol.geom.LineString');
goog.require('ol.geom.MultiLineString');
goog.require('ol.geom.MultiPoint');
@@ -74,7 +73,8 @@ ol.format.GeoJSON.readGeometry_ = function(object, opt_options) {
return null;
}
var geometryReader = ol.format.GeoJSON.GEOMETRY_READERS_[object.type];
goog.asserts.assert(goog.isDef(geometryReader));
goog.asserts.assert(goog.isDef(geometryReader),
'geometryReader should be defined');
return /** @type {ol.geom.Geometry} */ (
ol.format.Feature.transformWithOptions(
geometryReader(object), false, opt_options));
@@ -89,7 +89,8 @@ ol.format.GeoJSON.readGeometry_ = function(object, opt_options) {
*/
ol.format.GeoJSON.readGeometryCollectionGeometry_ = function(
object, opt_options) {
goog.asserts.assert(object.type == 'GeometryCollection');
goog.asserts.assert(object.type == 'GeometryCollection',
'object.type should be GeometryCollection');
var geometries = goog.array.map(object.geometries,
/**
* @param {GeoJSONGeometry} geometry Geometry.
@@ -108,7 +109,8 @@ ol.format.GeoJSON.readGeometryCollectionGeometry_ = function(
* @return {ol.geom.Point} Point.
*/
ol.format.GeoJSON.readPointGeometry_ = function(object) {
goog.asserts.assert(object.type == 'Point');
goog.asserts.assert(object.type == 'Point',
'object.type should be Point');
return new ol.geom.Point(object.coordinates);
};
@@ -119,7 +121,8 @@ ol.format.GeoJSON.readPointGeometry_ = function(object) {
* @return {ol.geom.LineString} LineString.
*/
ol.format.GeoJSON.readLineStringGeometry_ = function(object) {
goog.asserts.assert(object.type == 'LineString');
goog.asserts.assert(object.type == 'LineString',
'object.type should be LineString');
return new ol.geom.LineString(object.coordinates);
};
@@ -130,7 +133,8 @@ ol.format.GeoJSON.readLineStringGeometry_ = function(object) {
* @return {ol.geom.MultiLineString} MultiLineString.
*/
ol.format.GeoJSON.readMultiLineStringGeometry_ = function(object) {
goog.asserts.assert(object.type == 'MultiLineString');
goog.asserts.assert(object.type == 'MultiLineString',
'object.type should be MultiLineString');
return new ol.geom.MultiLineString(object.coordinates);
};
@@ -141,7 +145,8 @@ ol.format.GeoJSON.readMultiLineStringGeometry_ = function(object) {
* @return {ol.geom.MultiPoint} MultiPoint.
*/
ol.format.GeoJSON.readMultiPointGeometry_ = function(object) {
goog.asserts.assert(object.type == 'MultiPoint');
goog.asserts.assert(object.type == 'MultiPoint',
'object.type should be MultiPoint');
return new ol.geom.MultiPoint(object.coordinates);
};
@@ -152,7 +157,8 @@ ol.format.GeoJSON.readMultiPointGeometry_ = function(object) {
* @return {ol.geom.MultiPolygon} MultiPolygon.
*/
ol.format.GeoJSON.readMultiPolygonGeometry_ = function(object) {
goog.asserts.assert(object.type == 'MultiPolygon');
goog.asserts.assert(object.type == 'MultiPolygon',
'object.type should be MultiPolygon');
return new ol.geom.MultiPolygon(object.coordinates);
};
@@ -163,7 +169,8 @@ ol.format.GeoJSON.readMultiPolygonGeometry_ = function(object) {
* @return {ol.geom.Polygon} Polygon.
*/
ol.format.GeoJSON.readPolygonGeometry_ = function(object) {
goog.asserts.assert(object.type == 'Polygon');
goog.asserts.assert(object.type == 'Polygon',
'object.type should be Polygon');
return new ol.geom.Polygon(object.coordinates);
};
@@ -176,7 +183,8 @@ ol.format.GeoJSON.readPolygonGeometry_ = function(object) {
*/
ol.format.GeoJSON.writeGeometry_ = function(geometry, opt_options) {
var geometryWriter = ol.format.GeoJSON.GEOMETRY_WRITERS_[geometry.getType()];
goog.asserts.assert(goog.isDef(geometryWriter));
goog.asserts.assert(goog.isDef(geometryWriter),
'geometryWriter should be defined');
return geometryWriter(/** @type {ol.geom.Geometry} */ (
ol.format.Feature.transformWithOptions(geometry, true, opt_options)),
opt_options);
@@ -204,7 +212,8 @@ ol.format.GeoJSON.writeEmptyGeometryCollectionGeometry_ = function(geometry) {
*/
ol.format.GeoJSON.writeGeometryCollectionGeometry_ = function(
geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.GeometryCollection);
goog.asserts.assertInstanceof(geometry, ol.geom.GeometryCollection,
'geometry should be an ol.geom.GeometryCollection');
var geometries = goog.array.map(
geometry.getGeometriesArray(), function(geometry) {
return ol.format.GeoJSON.writeGeometry_(geometry, opt_options);
@@ -223,7 +232,8 @@ ol.format.GeoJSON.writeGeometryCollectionGeometry_ = function(
* @return {GeoJSONGeometry} GeoJSON geometry.
*/
ol.format.GeoJSON.writeLineStringGeometry_ = function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
return /** @type {GeoJSONGeometry} */ ({
'type': 'LineString',
'coordinates': geometry.getCoordinates()
@@ -239,9 +249,8 @@ ol.format.GeoJSON.writeLineStringGeometry_ = function(geometry, opt_options) {
*/
ol.format.GeoJSON.writeMultiLineStringGeometry_ =
function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString);
goog.asserts.assert(
geometry.getType() == ol.geom.GeometryType.MULTI_LINE_STRING);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString,
'geometry should be an ol.geom.MultiLineString');
return /** @type {GeoJSONGeometry} */ ({
'type': 'MultiLineString',
'coordinates': geometry.getCoordinates()
@@ -256,7 +265,8 @@ ol.format.GeoJSON.writeMultiLineStringGeometry_ =
* @return {GeoJSONGeometry} GeoJSON geometry.
*/
ol.format.GeoJSON.writeMultiPointGeometry_ = function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPoint);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPoint,
'geometry should be an ol.geom.MultiPoint');
return /** @type {GeoJSONGeometry} */ ({
'type': 'MultiPoint',
'coordinates': geometry.getCoordinates()
@@ -271,7 +281,8 @@ ol.format.GeoJSON.writeMultiPointGeometry_ = function(geometry, opt_options) {
* @return {GeoJSONGeometry} GeoJSON geometry.
*/
ol.format.GeoJSON.writeMultiPolygonGeometry_ = function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPolygon);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPolygon,
'geometry should be an ol.geom.MultiPolygon');
var right;
if (goog.isDef(opt_options)) {
right = opt_options.rightHanded;
@@ -290,7 +301,8 @@ ol.format.GeoJSON.writeMultiPolygonGeometry_ = function(geometry, opt_options) {
* @return {GeoJSONGeometry} GeoJSON geometry.
*/
ol.format.GeoJSON.writePointGeometry_ = function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
return /** @type {GeoJSONGeometry} */ ({
'type': 'Point',
'coordinates': geometry.getCoordinates()
@@ -305,7 +317,8 @@ ol.format.GeoJSON.writePointGeometry_ = function(geometry, opt_options) {
* @return {GeoJSONGeometry} GeoJSON geometry.
*/
ol.format.GeoJSON.writePolygonGeometry_ = function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
var right;
if (goog.isDef(opt_options)) {
right = opt_options.rightHanded;
@@ -390,7 +403,8 @@ ol.format.GeoJSON.prototype.readFeatures;
ol.format.GeoJSON.prototype.readFeatureFromObject = function(
object, opt_options) {
var geoJSONFeature = /** @type {GeoJSONFeature} */ (object);
goog.asserts.assert(geoJSONFeature.type == 'Feature');
goog.asserts.assert(geoJSONFeature.type == 'Feature',
'geoJSONFeature.type should be Feature');
var geometry = ol.format.GeoJSON.readGeometry_(geoJSONFeature.geometry,
opt_options);
var feature = new ol.Feature();
@@ -429,7 +443,7 @@ ol.format.GeoJSON.prototype.readFeaturesFromObject = function(
}
return features;
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown geoJSONObject.type: ' + geoJSONObject.type);
return [];
}
};
@@ -484,7 +498,7 @@ ol.format.GeoJSON.prototype.readProjectionFromObject = function(object) {
// is fixed and widely deployed.
return ol.proj.get('EPSG:' + crs.properties.code);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown crs.type: ' + crs.type);
return null;
}
} else {

31
src/ol/format/gml/gml2format.js
View File

@@ -55,7 +55,7 @@ ol.format.GML2.schemaLocation_ = ol.format.GMLBase.GMLNS +
ol.format.GML2.prototype.readFlatCoordinates_ = function(node, objectStack) {
var s = ol.xml.getAllTextContent(node, false).replace(/^\s*|\s*$/g, '');
var context = objectStack[0];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var containerSrs = context['srsName'];
var containerDimension = node.parentNode.getAttribute('srsDimension');
var axisOrientation = 'enu';
@@ -98,8 +98,9 @@ ol.format.GML2.prototype.readFlatCoordinates_ = function(node, objectStack) {
* @return {ol.Extent|undefined} Envelope.
*/
ol.format.GML2.prototype.readBox_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Box');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Box', 'localName should be Box');
var flatCoordinates = ol.xml.pushParseAndPop(
/** @type {Array.<number>} */ ([null]),
this.BOX_PARSERS_, node, objectStack, this);
@@ -116,16 +117,20 @@ ol.format.GML2.prototype.readBox_ = function(node, objectStack) {
*/
ol.format.GML2.prototype.innerBoundaryIsParser_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'innerBoundaryIs');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'innerBoundaryIs',
'localName should be innerBoundaryIs');
var flatLinearRing = ol.xml.pushParseAndPop(
/** @type {Array.<number>|undefined} */ (undefined),
this.RING_PARSERS, node, objectStack, this);
if (goog.isDef(flatLinearRing)) {
var flatLinearRings = /** @type {Array.<Array.<number>>} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isArray(flatLinearRings));
goog.asserts.assert(flatLinearRings.length > 0);
goog.asserts.assert(goog.isArray(flatLinearRings),
'flatLinearRings should be an array');
goog.asserts.assert(flatLinearRings.length > 0,
'flatLinearRings should have an array length larger than 0');
flatLinearRings.push(flatLinearRing);
}
};
@@ -138,16 +143,20 @@ ol.format.GML2.prototype.innerBoundaryIsParser_ =
*/
ol.format.GML2.prototype.outerBoundaryIsParser_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'outerBoundaryIs');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'outerBoundaryIs',
'localName should be outerBoundaryIs');
var flatLinearRing = ol.xml.pushParseAndPop(
/** @type {Array.<number>|undefined} */ (undefined),
this.RING_PARSERS, node, objectStack, this);
if (goog.isDef(flatLinearRing)) {
var flatLinearRings = /** @type {Array.<Array.<number>>} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isArray(flatLinearRings));
goog.asserts.assert(flatLinearRings.length > 0);
goog.asserts.assert(goog.isArray(flatLinearRings),
'flatLinearRings should be an array');
goog.asserts.assert(flatLinearRings.length > 0,
'flatLinearRings should have an array length larger than 0');
flatLinearRings[0] = flatLinearRing;
}
};

141
src/ol/format/gml/gml3format.js
View File

@@ -95,8 +95,10 @@ ol.format.GML3.schemaLocation_ = ol.format.GMLBase.GMLNS +
* @return {ol.geom.MultiLineString|undefined} MultiLineString.
*/
ol.format.GML3.prototype.readMultiCurve_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MultiCurve');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MultiCurve',
'localName should be MultiCurve');
var lineStrings = ol.xml.pushParseAndPop(
/** @type {Array.<ol.geom.LineString>} */ ([]),
this.MULTICURVE_PARSERS_, node, objectStack, this);
@@ -117,8 +119,10 @@ ol.format.GML3.prototype.readMultiCurve_ = function(node, objectStack) {
* @return {ol.geom.MultiPolygon|undefined} MultiPolygon.
*/
ol.format.GML3.prototype.readMultiSurface_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MultiSurface');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MultiSurface',
'localName should be MultiSurface');
var polygons = ol.xml.pushParseAndPop(
/** @type {Array.<ol.geom.Polygon>} */ ([]),
this.MULTISURFACE_PARSERS_, node, objectStack, this);
@@ -138,9 +142,11 @@ ol.format.GML3.prototype.readMultiSurface_ = function(node, objectStack) {
* @private
*/
ol.format.GML3.prototype.curveMemberParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'curveMember' ||
node.localName == 'curveMembers');
node.localName == 'curveMembers',
'localName should be curveMember or curveMembers');
ol.xml.parseNode(this.CURVEMEMBER_PARSERS_, node, objectStack, this);
};
@@ -151,9 +157,11 @@ ol.format.GML3.prototype.curveMemberParser_ = function(node, objectStack) {
* @private
*/
ol.format.GML3.prototype.surfaceMemberParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'surfaceMember' ||
node.localName == 'surfaceMembers');
node.localName == 'surfaceMembers',
'localName should be surfaceMember or surfaceMembers');
ol.xml.parseNode(this.SURFACEMEMBER_PARSERS_,
node, objectStack, this);
};
@@ -166,8 +174,10 @@ ol.format.GML3.prototype.surfaceMemberParser_ = function(node, objectStack) {
* @return {Array.<(Array.<number>)>|undefined} flat coordinates.
*/
ol.format.GML3.prototype.readPatch_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'patches');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'patches',
'localName should be patches');
return ol.xml.pushParseAndPop(
/** @type {Array.<Array.<number>>} */ ([null]),
this.PATCHES_PARSERS_, node, objectStack, this);
@@ -181,8 +191,10 @@ ol.format.GML3.prototype.readPatch_ = function(node, objectStack) {
* @return {Array.<number>|undefined} flat coordinates.
*/
ol.format.GML3.prototype.readSegment_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'segments');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'segments',
'localName should be segments');
return ol.xml.pushParseAndPop(
/** @type {Array.<number>} */ ([null]),
this.SEGMENTS_PARSERS_, node, objectStack, this);
@@ -196,8 +208,10 @@ ol.format.GML3.prototype.readSegment_ = function(node, objectStack) {
* @return {Array.<(Array.<number>)>|undefined} flat coordinates.
*/
ol.format.GML3.prototype.readPolygonPatch_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'PolygonPatch');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'npde.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'PolygonPatch',
'localName should be PolygonPatch');
return ol.xml.pushParseAndPop(
/** @type {Array.<Array.<number>>} */ ([null]),
this.FLAT_LINEAR_RINGS_PARSERS_, node, objectStack, this);
@@ -212,8 +226,10 @@ ol.format.GML3.prototype.readPolygonPatch_ = function(node, objectStack) {
*/
ol.format.GML3.prototype.readLineStringSegment_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LineStringSegment');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LineStringSegment',
'localName should be LineStringSegment');
return ol.xml.pushParseAndPop(
/** @type {Array.<number>} */ ([null]),
this.GEOMETRY_FLAT_COORDINATES_PARSERS_,
@@ -227,16 +243,20 @@ ol.format.GML3.prototype.readLineStringSegment_ =
* @private
*/
ol.format.GML3.prototype.interiorParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'interior');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'interior',
'localName should be interior');
var flatLinearRing = ol.xml.pushParseAndPop(
/** @type {Array.<number>|undefined} */ (undefined),
this.RING_PARSERS, node, objectStack, this);
if (goog.isDef(flatLinearRing)) {
var flatLinearRings = /** @type {Array.<Array.<number>>} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isArray(flatLinearRings));
goog.asserts.assert(flatLinearRings.length > 0);
goog.asserts.assert(goog.isArray(flatLinearRings),
'flatLinearRings should be an array');
goog.asserts.assert(flatLinearRings.length > 0,
'flatLinearRings should have an array length of 1 or more');
flatLinearRings.push(flatLinearRing);
}
};
@@ -248,16 +268,20 @@ ol.format.GML3.prototype.interiorParser_ = function(node, objectStack) {
* @private
*/
ol.format.GML3.prototype.exteriorParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'exterior');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'exterior',
'localName should be exterior');
var flatLinearRing = ol.xml.pushParseAndPop(
/** @type {Array.<number>|undefined} */ (undefined),
this.RING_PARSERS, node, objectStack, this);
if (goog.isDef(flatLinearRing)) {
var flatLinearRings = /** @type {Array.<Array.<number>>} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isArray(flatLinearRings));
goog.asserts.assert(flatLinearRings.length > 0);
goog.asserts.assert(goog.isArray(flatLinearRings),
'flatLinearRings should be an array');
goog.asserts.assert(flatLinearRings.length > 0,
'flatLinearRings should have an array length of 1 or more');
flatLinearRings[0] = flatLinearRing;
}
};
@@ -270,8 +294,10 @@ ol.format.GML3.prototype.exteriorParser_ = function(node, objectStack) {
* @return {ol.geom.Polygon|undefined} Polygon.
*/
ol.format.GML3.prototype.readSurface_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Surface');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Surface',
'localName should be Surface');
var flatLinearRings = ol.xml.pushParseAndPop(
/** @type {Array.<Array.<number>>} */ ([null]),
this.SURFACE_PARSERS_, node, objectStack, this);
@@ -301,8 +327,9 @@ ol.format.GML3.prototype.readSurface_ = function(node, objectStack) {
* @return {ol.geom.LineString|undefined} LineString.
*/
ol.format.GML3.prototype.readCurve_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Curve');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Curve', 'localName should be Curve');
var flatCoordinates = ol.xml.pushParseAndPop(
/** @type {Array.<number>} */ ([null]),
this.CURVE_PARSERS_, node, objectStack, this);
@@ -323,8 +350,10 @@ ol.format.GML3.prototype.readCurve_ = function(node, objectStack) {
* @return {ol.Extent|undefined} Envelope.
*/
ol.format.GML3.prototype.readEnvelope_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Envelope');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Envelope',
'localName should be Envelope');
var flatCoordinates = ol.xml.pushParseAndPop(
/** @type {Array.<number>} */ ([null]),
this.ENVELOPE_PARSERS_, node, objectStack, this);
@@ -354,7 +383,7 @@ ol.format.GML3.prototype.readFlatPos_ = function(node, objectStack) {
return undefined;
}
var context = objectStack[0];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var containerSrs = context['srsName'];
var axisOrientation = 'enu';
if (!goog.isNull(containerSrs)) {
@@ -390,7 +419,7 @@ ol.format.GML3.prototype.readFlatPos_ = function(node, objectStack) {
ol.format.GML3.prototype.readFlatPosList_ = function(node, objectStack) {
var s = ol.xml.getAllTextContent(node, false).replace(/^\s*|\s*$/g, '');
var context = objectStack[0];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var containerSrs = context['srsName'];
var containerDimension = node.parentNode.getAttribute('srsDimension');
var axisOrientation = 'enu';
@@ -612,7 +641,7 @@ ol.format.GML3.prototype.SEGMENTS_PARSERS_ = Object({
*/
ol.format.GML3.prototype.writePos_ = function(node, value, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
var axisOrientation = 'enu';
if (goog.isDefAndNotNull(srsName)) {
@@ -655,7 +684,7 @@ ol.format.GML3.prototype.getCoords_ = function(point, opt_srsName) {
*/
ol.format.GML3.prototype.writePosList_ = function(node, value, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
// only 2d for simple features profile
var points = value.getCoordinates();
@@ -678,7 +707,7 @@ ol.format.GML3.prototype.writePosList_ = function(node, value, objectStack) {
*/
ol.format.GML3.prototype.writePoint_ = function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
if (goog.isDefAndNotNull(srsName)) {
node.setAttribute('srsName', srsName);
@@ -707,9 +736,9 @@ ol.format.GML3.ENVELOPE_SERIALIZERS_ = {
* @param {Array.<*>} objectStack Node stack.
*/
ol.format.GML3.prototype.writeEnvelope = function(node, extent, objectStack) {
goog.asserts.assert(extent.length == 4);
goog.asserts.assert(extent.length == 4, 'extent should have 4 items');
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
if (goog.isDef(srsName)) {
node.setAttribute('srsName', srsName);
@@ -733,7 +762,7 @@ ol.format.GML3.prototype.writeEnvelope = function(node, extent, objectStack) {
ol.format.GML3.prototype.writeLinearRing_ =
function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
if (goog.isDefAndNotNull(srsName)) {
node.setAttribute('srsName', srsName);
@@ -755,7 +784,7 @@ ol.format.GML3.prototype.RING_NODE_FACTORY_ =
function(value, objectStack, opt_nodeName) {
var context = objectStack[objectStack.length - 1];
var parentNode = context.node;
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var exteriorWritten = context['exteriorWritten'];
if (!goog.isDef(exteriorWritten)) {
context['exteriorWritten'] = true;
@@ -774,7 +803,7 @@ ol.format.GML3.prototype.RING_NODE_FACTORY_ =
ol.format.GML3.prototype.writeSurfaceOrPolygon_ =
function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
if (node.nodeName !== 'PolygonPatch' && goog.isDefAndNotNull(srsName)) {
node.setAttribute('srsName', srsName);
@@ -804,7 +833,7 @@ ol.format.GML3.prototype.writeSurfaceOrPolygon_ =
ol.format.GML3.prototype.writeCurveOrLineString_ =
function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
if (node.nodeName !== 'LineStringSegment' &&
goog.isDefAndNotNull(srsName)) {
@@ -833,7 +862,7 @@ ol.format.GML3.prototype.writeCurveOrLineString_ =
ol.format.GML3.prototype.writeMultiSurfaceOrPolygon_ =
function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
var surface = context['surface'];
if (goog.isDefAndNotNull(srsName)) {
@@ -856,7 +885,7 @@ ol.format.GML3.prototype.writeMultiSurfaceOrPolygon_ =
ol.format.GML3.prototype.writeMultiPoint_ = function(node, geometry,
objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
if (goog.isDefAndNotNull(srsName)) {
node.setAttribute('srsName', srsName);
@@ -878,7 +907,7 @@ ol.format.GML3.prototype.writeMultiPoint_ = function(node, geometry,
ol.format.GML3.prototype.writeMultiCurveOrLineString_ =
function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var srsName = context['srsName'];
var curve = context['curve'];
if (goog.isDefAndNotNull(srsName)) {
@@ -914,7 +943,7 @@ ol.format.GML3.prototype.writeRing_ = function(node, ring, objectStack) {
ol.format.GML3.prototype.writeSurfaceOrPolygonMember_ =
function(node, polygon, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var child = this.GEOMETRY_NODE_FACTORY_(
polygon, objectStack);
if (goog.isDef(child)) {
@@ -947,7 +976,7 @@ ol.format.GML3.prototype.writePointMember_ =
ol.format.GML3.prototype.writeLineStringOrCurveMember_ =
function(node, line, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var child = this.GEOMETRY_NODE_FACTORY_(line, objectStack);
if (goog.isDef(child)) {
node.appendChild(child);
@@ -993,7 +1022,7 @@ ol.format.GML3.prototype.writeCurveSegments_ =
ol.format.GML3.prototype.writeGeometryElement =
function(node, geometry, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var item = goog.object.clone(context);
item.node = node;
var value;
@@ -1005,7 +1034,8 @@ ol.format.GML3.prototype.writeGeometryElement =
value = geometry;
}
} else {
goog.asserts.assertInstanceof(geometry, ol.geom.Geometry);
goog.asserts.assertInstanceof(geometry, ol.geom.Geometry,
'geometry should be an ol.geom.Geometry');
value =
ol.format.Feature.transformWithOptions(geometry, true, context);
}
@@ -1028,7 +1058,7 @@ ol.format.GML3.prototype.writeFeatureElement =
node.setAttribute('fid', fid);
}
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featureNS = context['featureNS'];
var geometryName = feature.getGeometryName();
if (!goog.isDef(context.serializers)) {
@@ -1074,7 +1104,7 @@ ol.format.GML3.prototype.writeFeatureElement =
ol.format.GML3.prototype.writeFeatureMembers_ =
function(node, features, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featureType = context['featureType'];
var featureNS = context['featureNS'];
var serializers = {};
@@ -1200,7 +1230,8 @@ ol.format.GML3.MULTIGEOMETRY_TO_MEMBER_NODENAME_ = {
ol.format.GML3.prototype.MULTIGEOMETRY_MEMBER_NODE_FACTORY_ =
function(value, objectStack, opt_nodeName) {
var parentNode = objectStack[objectStack.length - 1].node;
goog.asserts.assert(ol.xml.isNode(parentNode));
goog.asserts.assert(ol.xml.isNode(parentNode),
'parentNode should be a node');
return ol.xml.createElementNS('http://www.opengis.net/gml',
ol.format.GML3.MULTIGEOMETRY_TO_MEMBER_NODENAME_[parentNode.nodeName]);
};
@@ -1217,16 +1248,18 @@ ol.format.GML3.prototype.MULTIGEOMETRY_MEMBER_NODE_FACTORY_ =
ol.format.GML3.prototype.GEOMETRY_NODE_FACTORY_ =
function(value, objectStack, opt_nodeName) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var multiSurface = context['multiSurface'];
var surface = context['surface'];
var curve = context['curve'];
var multiCurve = context['multiCurve'];
var parentNode = objectStack[objectStack.length - 1].node;
goog.asserts.assert(ol.xml.isNode(parentNode));
goog.asserts.assert(ol.xml.isNode(parentNode),
'parentNode should be a node');
var nodeName;
if (!goog.isArray(value)) {
goog.asserts.assertInstanceof(value, ol.geom.Geometry);
goog.asserts.assertInstanceof(value, ol.geom.Geometry,
'value should be an ol.geom.Geometry');
nodeName = value.getType();
if (nodeName === 'MultiPolygon' && multiSurface === true) {
nodeName = 'MultiSurface';

78
src/ol/format/gml/gmlbaseformat.js
View File

@@ -96,7 +96,8 @@ ol.format.GMLBase.GMLNS = 'http://www.opengis.net/gml';
* @return {Array.<ol.Feature>} Features.
*/
ol.format.GMLBase.prototype.readFeaturesInternal = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
var localName = ol.xml.getLocalName(node);
var features;
if (localName == 'FeatureCollection') {
@@ -105,7 +106,7 @@ ol.format.GMLBase.prototype.readFeaturesInternal = function(node, objectStack) {
objectStack, this);
} else if (localName == 'featureMembers' || localName == 'featureMember') {
var context = objectStack[0];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featureType = context['featureType'];
var featureNS = context['featureNS'];
var i, ii, prefix = 'p', defaultPrefix = 'p0';
@@ -169,7 +170,7 @@ ol.format.GMLBase.prototype.readFeaturesInternal = function(node, objectStack) {
*/
ol.format.GMLBase.prototype.readGeometryElement = function(node, objectStack) {
var context = objectStack[0];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
context['srsName'] = node.firstElementChild.getAttribute('srsName');
var geometry = ol.xml.pushParseAndPop(/** @type {ol.geom.Geometry} */(null),
this.GEOMETRY_PARSERS_, node, objectStack, this);
@@ -230,13 +231,15 @@ ol.format.GMLBase.prototype.readFeatureElement = function(node, objectStack) {
* @return {ol.geom.Point|undefined} Point.
*/
ol.format.GMLBase.prototype.readPoint = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Point');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Point', 'localName should be Point');
var flatCoordinates =
this.readFlatCoordinatesFromNode_(node, objectStack);
if (goog.isDefAndNotNull(flatCoordinates)) {
var point = new ol.geom.Point(null);
goog.asserts.assert(flatCoordinates.length == 3);
goog.asserts.assert(flatCoordinates.length == 3,
'flatCoordinates should have a length of 3');
point.setFlatCoordinates(ol.geom.GeometryLayout.XYZ, flatCoordinates);
return point;
}
@@ -249,8 +252,10 @@ ol.format.GMLBase.prototype.readPoint = function(node, objectStack) {
* @return {ol.geom.MultiPoint|undefined} MultiPoint.
*/
ol.format.GMLBase.prototype.readMultiPoint = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MultiPoint');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MultiPoint',
'localName should be MultiPoint');
var coordinates = ol.xml.pushParseAndPop(
/** @type {Array.<Array.<number>>} */ ([]),
this.MULTIPOINT_PARSERS_, node, objectStack, this);
@@ -268,8 +273,10 @@ ol.format.GMLBase.prototype.readMultiPoint = function(node, objectStack) {
* @return {ol.geom.MultiLineString|undefined} MultiLineString.
*/
ol.format.GMLBase.prototype.readMultiLineString = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MultiLineString');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MultiLineString',
'localName should be MultiLineString');
var lineStrings = ol.xml.pushParseAndPop(
/** @type {Array.<ol.geom.LineString>} */ ([]),
this.MULTILINESTRING_PARSERS_, node, objectStack, this);
@@ -289,8 +296,10 @@ ol.format.GMLBase.prototype.readMultiLineString = function(node, objectStack) {
* @return {ol.geom.MultiPolygon|undefined} MultiPolygon.
*/
ol.format.GMLBase.prototype.readMultiPolygon = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MultiPolygon');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MultiPolygon',
'localName should be MultiPolygon');
var polygons = ol.xml.pushParseAndPop(
/** @type {Array.<ol.geom.Polygon>} */ ([]),
this.MULTIPOLYGON_PARSERS_, node, objectStack, this);
@@ -310,9 +319,11 @@ ol.format.GMLBase.prototype.readMultiPolygon = function(node, objectStack) {
* @private
*/
ol.format.GMLBase.prototype.pointMemberParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'pointMember' ||
node.localName == 'pointMembers');
node.localName == 'pointMembers',
'localName should be pointMember or pointMembers');
ol.xml.parseNode(this.POINTMEMBER_PARSERS_,
node, objectStack, this);
};
@@ -325,9 +336,11 @@ ol.format.GMLBase.prototype.pointMemberParser_ = function(node, objectStack) {
*/
ol.format.GMLBase.prototype.lineStringMemberParser_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'lineStringMember' ||
node.localName == 'lineStringMembers');
node.localName == 'lineStringMembers',
'localName should be LineStringMember or LineStringMembers');
ol.xml.parseNode(this.LINESTRINGMEMBER_PARSERS_,
node, objectStack, this);
};
@@ -340,9 +353,11 @@ ol.format.GMLBase.prototype.lineStringMemberParser_ =
*/
ol.format.GMLBase.prototype.polygonMemberParser_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'polygonMember' ||
node.localName == 'polygonMembers');
node.localName == 'polygonMembers',
'localName should be polygonMember or polygonMembers');
ol.xml.parseNode(this.POLYGONMEMBER_PARSERS_, node,
objectStack, this);
};
@@ -354,8 +369,10 @@ ol.format.GMLBase.prototype.polygonMemberParser_ =
* @return {ol.geom.LineString|undefined} LineString.
*/
ol.format.GMLBase.prototype.readLineString = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LineString');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LineString',
'localName should be LineString');
var flatCoordinates =
this.readFlatCoordinatesFromNode_(node, objectStack);
if (goog.isDefAndNotNull(flatCoordinates)) {
@@ -375,8 +392,10 @@ ol.format.GMLBase.prototype.readLineString = function(node, objectStack) {
* @return {Array.<number>|undefined} LinearRing flat coordinates.
*/
ol.format.GMLBase.prototype.readFlatLinearRing_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LinearRing');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LinearRing',
'localName should be LinearRing');
var ring = ol.xml.pushParseAndPop(/** @type {Array.<number>} */(null),
this.GEOMETRY_FLAT_COORDINATES_PARSERS_, node,
objectStack, this);
@@ -394,8 +413,10 @@ ol.format.GMLBase.prototype.readFlatLinearRing_ = function(node, objectStack) {
* @return {ol.geom.LinearRing|undefined} LinearRing.
*/
ol.format.GMLBase.prototype.readLinearRing = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LinearRing');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LinearRing',
'localName should be LinearRing');
var flatCoordinates =
this.readFlatCoordinatesFromNode_(node, objectStack);
if (goog.isDef(flatCoordinates)) {
@@ -414,8 +435,10 @@ ol.format.GMLBase.prototype.readLinearRing = function(node, objectStack) {
* @return {ol.geom.Polygon|undefined} Polygon.
*/
ol.format.GMLBase.prototype.readPolygon = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Polygon');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Polygon',
'localName should be Polygon');
var flatLinearRings = ol.xml.pushParseAndPop(
/** @type {Array.<Array.<number>>} */ ([null]),
this.FLAT_LINEAR_RINGS_PARSERS_, node, objectStack, this);
@@ -446,7 +469,8 @@ ol.format.GMLBase.prototype.readPolygon = function(node, objectStack) {
*/
ol.format.GMLBase.prototype.readFlatCoordinatesFromNode_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return /** @type {Array.<number>} */ (ol.xml.pushParseAndPop(
null,
this.GEOMETRY_FLAT_COORDINATES_PARSERS_, node,

75
src/ol/format/gpxformat.js
View File

@@ -65,7 +65,8 @@ ol.format.GPX.NAMESPACE_URIS_ = [
* @return {Array.<number>} Flat coordinates.
*/
ol.format.GPX.appendCoordinate_ = function(flatCoordinates, node, values) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
flatCoordinates.push(
parseFloat(node.getAttribute('lon')),
parseFloat(node.getAttribute('lat')));
@@ -93,8 +94,9 @@ ol.format.GPX.appendCoordinate_ = function(flatCoordinates, node, values) {
* @private
*/
ol.format.GPX.parseLink_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'link');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'link', 'localName should be link');
var values = /** @type {Object} */ (objectStack[objectStack.length - 1]);
var href = node.getAttribute('href');
if (!goog.isNull(href)) {
@@ -110,8 +112,10 @@ ol.format.GPX.parseLink_ = function(node, objectStack) {
* @private
*/
ol.format.GPX.parseExtensions_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'extensions');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'extensions',
'localName should be extensions');
var values = /** @type {Object} */ (objectStack[objectStack.length - 1]);
values['extensionsNode_'] = node;
};
@@ -123,8 +127,9 @@ ol.format.GPX.parseExtensions_ = function(node, objectStack) {
* @private
*/
ol.format.GPX.parseRtePt_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'rtept');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'rtept', 'localName should be rtept');
var values = ol.xml.pushParseAndPop(
{}, ol.format.GPX.RTEPT_PARSERS_, node, objectStack);
if (goog.isDef(values)) {
@@ -142,8 +147,9 @@ ol.format.GPX.parseRtePt_ = function(node, objectStack) {
* @private
*/
ol.format.GPX.parseTrkPt_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'trkpt');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'trkpt', 'localName should be trkpt');
var values = ol.xml.pushParseAndPop(
{}, ol.format.GPX.TRKPT_PARSERS_, node, objectStack);
if (goog.isDef(values)) {
@@ -161,8 +167,10 @@ ol.format.GPX.parseTrkPt_ = function(node, objectStack) {
* @private
*/
ol.format.GPX.parseTrkSeg_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'trkseg');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'trkseg',
'localName should be trkseg');
var values = /** @type {Object} */ (objectStack[objectStack.length - 1]);
ol.xml.parseNode(ol.format.GPX.TRKSEG_PARSERS_, node, objectStack);
var flatCoordinates = /** @type {Array.<number>} */
@@ -179,8 +187,9 @@ ol.format.GPX.parseTrkSeg_ = function(node, objectStack) {
* @return {ol.Feature|undefined} Track.
*/
ol.format.GPX.readRte_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'rte');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'rte', 'localName should be rte');
var options = /** @type {olx.format.ReadOptions} */ (objectStack[0]);
var values = ol.xml.pushParseAndPop({
'flatCoordinates': []
@@ -207,8 +216,9 @@ ol.format.GPX.readRte_ = function(node, objectStack) {
* @return {ol.Feature|undefined} Track.
*/
ol.format.GPX.readTrk_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'trk');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'trk', 'localName should be trk');
var options = /** @type {olx.format.ReadOptions} */ (objectStack[0]);
var values = ol.xml.pushParseAndPop({
'flatCoordinates': [],
@@ -239,8 +249,9 @@ ol.format.GPX.readTrk_ = function(node, objectStack) {
* @return {ol.Feature|undefined} Waypoint.
*/
ol.format.GPX.readWpt_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'wpt');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'wpt', 'localName should be wpt');
var options = /** @type {olx.format.ReadOptions} */ (objectStack[0]);
var values = ol.xml.pushParseAndPop(
{}, ol.format.GPX.WPT_PARSERS_, node, objectStack);
@@ -438,7 +449,8 @@ ol.format.GPX.prototype.readFeature;
* @inheritDoc
*/
ol.format.GPX.prototype.readFeatureFromNode = function(node, opt_options) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
if (!goog.array.contains(ol.format.GPX.NAMESPACE_URIS_, node.namespaceURI)) {
return null;
}
@@ -471,7 +483,8 @@ ol.format.GPX.prototype.readFeatures;
* @inheritDoc
*/
ol.format.GPX.prototype.readFeaturesFromNode = function(node, opt_options) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
if (!goog.array.contains(ol.format.GPX.NAMESPACE_URIS_, node.namespaceURI)) {
return [];
}
@@ -510,7 +523,7 @@ ol.format.GPX.prototype.readProjection;
ol.format.GPX.writeLink_ = function(node, value, objectStack) {
node.setAttribute('href', value);
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var properties = context['properties'];
var link = [
properties['linkText'],
@@ -530,9 +543,10 @@ ol.format.GPX.writeLink_ = function(node, value, objectStack) {
*/
ol.format.GPX.writeWptType_ = function(node, coordinate, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var parentNode = context.node;
goog.asserts.assert(ol.xml.isNode(parentNode));
goog.asserts.assert(ol.xml.isNode(parentNode),
'parentNode should be an XML node');
var namespaceURI = parentNode.namespaceURI;
var properties = context['properties'];
//FIXME Projection handling
@@ -577,7 +591,8 @@ ol.format.GPX.writeRte_ = function(node, feature, objectStack) {
var context = {node: node, 'properties': properties};
var geometry = feature.getGeometry();
if (goog.isDef(geometry)) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
geometry = /** @type {ol.geom.LineString} */
(ol.format.Feature.transformWithOptions(geometry, true, options));
context['geometryLayout'] = geometry.getLayout();
@@ -604,7 +619,8 @@ ol.format.GPX.writeTrk_ = function(node, feature, objectStack) {
var context = {node: node, 'properties': properties};
var geometry = feature.getGeometry();
if (goog.isDef(geometry)) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString,
'geometry should be an ol.geom.MultiLineString');
geometry = /** @type {ol.geom.MultiLineString} */
(ol.format.Feature.transformWithOptions(geometry, true, options));
properties['trkseg'] = geometry.getLineStrings();
@@ -642,11 +658,12 @@ ol.format.GPX.writeTrkSeg_ = function(node, lineString, objectStack) {
ol.format.GPX.writeWpt_ = function(node, feature, objectStack) {
var options = /** @type {olx.format.WriteOptions} */ (objectStack[0]);
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
context['properties'] = feature.getProperties();
var geometry = feature.getGeometry();
if (goog.isDef(geometry)) {
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
geometry = /** @type {ol.geom.Point} */
(ol.format.Feature.transformWithOptions(geometry, true, options));
context['geometryLayout'] = geometry.getLayout();
@@ -820,11 +837,13 @@ ol.format.GPX.GEOMETRY_TYPE_TO_NODENAME_ = {
* @private
*/
ol.format.GPX.GPX_NODE_FACTORY_ = function(value, objectStack, opt_nodeName) {
goog.asserts.assertInstanceof(value, ol.Feature);
goog.asserts.assertInstanceof(value, ol.Feature,
'value should be an ol.Feature');
var geometry = value.getGeometry();
if (goog.isDef(geometry)) {
var parentNode = objectStack[objectStack.length - 1].node;
goog.asserts.assert(ol.xml.isNode(parentNode));
goog.asserts.assert(ol.xml.isNode(parentNode),
'parentNode should be an XML node');
return ol.xml.createElementNS(parentNode.namespaceURI,
ol.format.GPX.GEOMETRY_TYPE_TO_NODENAME_[geometry.getType()]);
}

277
src/ol/format/kmlformat.js
View File

@@ -455,8 +455,10 @@ ol.format.KML.readStyleMapValue_ = function(node, objectStack) {
* @private
*/
ol.format.KML.IconStyleParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'IconStyle');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be an ELEMENT');
goog.asserts.assert(node.localName == 'IconStyle',
'localName should be IconStyle');
// FIXME refreshMode
// FIXME refreshInterval
// FIXME viewRefreshTime
@@ -469,7 +471,8 @@ ol.format.KML.IconStyleParser_ = function(node, objectStack) {
return;
}
var styleObject = /** @type {Object} */ (objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isObject(styleObject));
goog.asserts.assert(goog.isObject(styleObject),
'styleObject should be an Object');
var IconObject = /** @type {Object} */ (goog.object.get(object, 'Icon', {}));
var src;
var href = /** @type {string|undefined} */
@@ -550,8 +553,10 @@ ol.format.KML.IconStyleParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.LabelStyleParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LabelStyle');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LabelStyle',
'localName should be LabelStyle');
// FIXME colorMode
var object = ol.xml.pushParseAndPop(
{}, ol.format.KML.LABEL_STYLE_PARSERS_, node, objectStack);
@@ -559,7 +564,8 @@ ol.format.KML.LabelStyleParser_ = function(node, objectStack) {
return;
}
var styleObject = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(styleObject));
goog.asserts.assert(goog.isObject(styleObject),
'styleObject should be an Object');
var textStyle = new ol.style.Text({
fill: new ol.style.Fill({
color: /** @type {ol.Color} */
@@ -578,8 +584,10 @@ ol.format.KML.LabelStyleParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.LineStyleParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LineStyle');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LineStyle',
'localName should be LineStyle');
// FIXME colorMode
// FIXME gx:outerColor
// FIXME gx:outerWidth
@@ -591,7 +599,8 @@ ol.format.KML.LineStyleParser_ = function(node, objectStack) {
return;
}
var styleObject = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(styleObject));
goog.asserts.assert(goog.isObject(styleObject),
'styleObject should be an Object');
var strokeStyle = new ol.style.Stroke({
color: /** @type {ol.Color} */
(goog.object.get(object, 'color', ol.format.KML.DEFAULT_COLOR_)),
@@ -607,8 +616,10 @@ ol.format.KML.LineStyleParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.PolyStyleParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'PolyStyle');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'PolyStyle',
'localName should be PolyStyle');
// FIXME colorMode
var object = ol.xml.pushParseAndPop(
{}, ol.format.KML.POLY_STYLE_PARSERS_, node, objectStack);
@@ -616,7 +627,8 @@ ol.format.KML.PolyStyleParser_ = function(node, objectStack) {
return;
}
var styleObject = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(styleObject));
goog.asserts.assert(goog.isObject(styleObject),
'styleObject should be an Object');
var fillStyle = new ol.style.Fill({
color: /** @type {ol.Color} */
(goog.object.get(object, 'color', ol.format.KML.DEFAULT_COLOR_))
@@ -641,8 +653,10 @@ ol.format.KML.PolyStyleParser_ = function(node, objectStack) {
* @return {Array.<number>} LinearRing flat coordinates.
*/
ol.format.KML.readFlatLinearRing_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LinearRing');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LinearRing',
'localName should be LinearRing');
return /** @type {Array.<number>} */ (ol.xml.pushParseAndPop(
null, ol.format.KML.FLAT_LINEAR_RING_PARSERS_, node, objectStack));
};
@@ -654,13 +668,16 @@ ol.format.KML.readFlatLinearRing_ = function(node, objectStack) {
* @private
*/
ol.format.KML.gxCoordParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(goog.array.contains(
ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI));
goog.asserts.assert(node.localName == 'coord');
ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI),
'namespaceURI of the node should be known to the KML parser');
goog.asserts.assert(node.localName == 'coord', 'localName should be coord');
var gxTrackObject = /** @type {ol.format.KMLGxTrackObject_} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isObject(gxTrackObject));
goog.asserts.assert(goog.isObject(gxTrackObject),
'gxTrackObject should be an Object');
var flatCoordinates = gxTrackObject.flatCoordinates;
var s = ol.xml.getAllTextContent(node, false);
var re =
@@ -684,10 +701,13 @@ ol.format.KML.gxCoordParser_ = function(node, objectStack) {
* @return {ol.geom.MultiLineString|undefined} MultiLineString.
*/
ol.format.KML.readGxMultiTrack_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(goog.array.contains(
ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI));
goog.asserts.assert(node.localName == 'MultiTrack');
ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI),
'namespaceURI of the node should be known to the KML parser');
goog.asserts.assert(node.localName == 'MultiTrack',
'localName should be MultiTrack');
var lineStrings = ol.xml.pushParseAndPop(
/** @type {Array.<ol.geom.LineString>} */ ([]),
ol.format.KML.GX_MULTITRACK_GEOMETRY_PARSERS_, node, objectStack);
@@ -707,10 +727,12 @@ ol.format.KML.readGxMultiTrack_ = function(node, objectStack) {
* @return {ol.geom.LineString|undefined} LineString.
*/
ol.format.KML.readGxTrack_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(goog.array.contains(
ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI));
goog.asserts.assert(node.localName == 'Track');
ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI),
'namespaceURI of the node should be known to the KML parser');
goog.asserts.assert(node.localName == 'Track', 'localName should be Track');
var gxTrackObject = ol.xml.pushParseAndPop(
/** @type {ol.format.KMLGxTrackObject_} */ ({
flatCoordinates: [],
@@ -721,7 +743,9 @@ ol.format.KML.readGxTrack_ = function(node, objectStack) {
}
var flatCoordinates = gxTrackObject.flatCoordinates;
var whens = gxTrackObject.whens;
goog.asserts.assert(flatCoordinates.length / 4 == whens.length);
goog.asserts.assert(flatCoordinates.length / 4 == whens.length,
'the length of the flatCoordinates array divided by 4 should be the ' +
'length of the whens array');
var i, ii;
for (i = 0, ii = Math.min(flatCoordinates.length, whens.length); i < ii;
++i) {
@@ -740,8 +764,9 @@ ol.format.KML.readGxTrack_ = function(node, objectStack) {
* @return {Object} Icon object.
*/
ol.format.KML.readIcon_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Icon');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Icon', 'localName should be Icon');
var iconObject = ol.xml.pushParseAndPop(
{}, ol.format.KML.ICON_PARSERS_, node, objectStack);
if (goog.isDef(iconObject)) {
@@ -759,7 +784,8 @@ ol.format.KML.readIcon_ = function(node, objectStack) {
* @return {Array.<number>} Flat coordinates.
*/
ol.format.KML.readFlatCoordinatesFromNode_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return /** @type {Array.<number>} */ (ol.xml.pushParseAndPop(null,
ol.format.KML.GEOMETRY_FLAT_COORDINATES_PARSERS_, node, objectStack));
};
@@ -772,8 +798,10 @@ ol.format.KML.readFlatCoordinatesFromNode_ = function(node, objectStack) {
* @return {ol.geom.LineString|undefined} LineString.
*/
ol.format.KML.readLineString_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LineString');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LineString',
'localName should be LineString');
var flatCoordinates =
ol.format.KML.readFlatCoordinatesFromNode_(node, objectStack);
if (goog.isDef(flatCoordinates)) {
@@ -793,8 +821,10 @@ ol.format.KML.readLineString_ = function(node, objectStack) {
* @return {ol.geom.Polygon|undefined} Polygon.
*/
ol.format.KML.readLinearRing_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'LinearRing');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'LinearRing',
'localName should be LinearRing');
var flatCoordinates =
ol.format.KML.readFlatCoordinatesFromNode_(node, objectStack);
if (goog.isDef(flatCoordinates)) {
@@ -815,8 +845,10 @@ ol.format.KML.readLinearRing_ = function(node, objectStack) {
* @return {ol.geom.Geometry} Geometry.
*/
ol.format.KML.readMultiGeometry_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MultiGeometry');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MultiGeometry',
'localName should be MultiGeometry');
var geometries = ol.xml.pushParseAndPop(
/** @type {Array.<ol.geom.Geometry>} */ ([]),
ol.format.KML.MULTI_GEOMETRY_PARSERS_, node, objectStack);
@@ -843,13 +875,16 @@ ol.format.KML.readMultiGeometry_ = function(node, objectStack) {
var flatCoordinates;
if (type == ol.geom.GeometryType.POINT) {
var point = geometries[0];
goog.asserts.assertInstanceof(point, ol.geom.Point);
goog.asserts.assertInstanceof(point, ol.geom.Point,
'point should be an ol.geom.Point');
layout = point.getLayout();
flatCoordinates = point.getFlatCoordinates();
for (i = 1, ii = geometries.length; i < ii; ++i) {
geometry = geometries[i];
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assert(geometry.getLayout() == layout);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
goog.asserts.assert(geometry.getLayout() == layout,
'geometry layout should be consistent');
goog.array.extend(flatCoordinates, geometry.getFlatCoordinates());
}
var multiPoint = new ol.geom.MultiPoint(null);
@@ -866,7 +901,7 @@ ol.format.KML.readMultiGeometry_ = function(node, objectStack) {
} else if (type == ol.geom.GeometryType.GEOMETRY_COLLECTION) {
return new ol.geom.GeometryCollection(geometries);
} else {
goog.asserts.fail();
goog.asserts.fail('Unexpected type: ' + type);
return null;
}
} else {
@@ -882,13 +917,15 @@ ol.format.KML.readMultiGeometry_ = function(node, objectStack) {
* @return {ol.geom.Point|undefined} Point.
*/
ol.format.KML.readPoint_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Point');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Point', 'localName should be Point');
var flatCoordinates =
ol.format.KML.readFlatCoordinatesFromNode_(node, objectStack);
if (goog.isDefAndNotNull(flatCoordinates)) {
var point = new ol.geom.Point(null);
goog.asserts.assert(flatCoordinates.length == 3);
goog.asserts.assert(flatCoordinates.length == 3,
'flatCoordinates should have a length of 3');
point.setFlatCoordinates(ol.geom.GeometryLayout.XYZ, flatCoordinates);
return point;
} else {
@@ -904,8 +941,10 @@ ol.format.KML.readPoint_ = function(node, objectStack) {
* @return {ol.geom.Polygon|undefined} Polygon.
*/
ol.format.KML.readPolygon_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Polygon');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Polygon',
'localName should be Polygon');
var flatLinearRings = ol.xml.pushParseAndPop(
/** @type {Array.<Array.<number>>} */ ([null]),
ol.format.KML.FLAT_LINEAR_RINGS_PARSERS_, node, objectStack);
@@ -935,8 +974,9 @@ ol.format.KML.readPolygon_ = function(node, objectStack) {
* @return {Array.<ol.style.Style>} Style.
*/
ol.format.KML.readStyle_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Style');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Style', 'localName should be Style');
var styleObject = ol.xml.pushParseAndPop(
{}, ol.format.KML.STYLE_PARSERS_, node, objectStack);
if (!goog.isDef(styleObject)) {
@@ -976,8 +1016,9 @@ ol.format.KML.readStyle_ = function(node, objectStack) {
* @private
*/
ol.format.KML.DataParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Data');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Data', 'localName should be Data');
var name = node.getAttribute('name');
if (!goog.isNull(name)) {
var data = ol.xml.pushParseAndPop(
@@ -985,7 +1026,8 @@ ol.format.KML.DataParser_ = function(node, objectStack) {
if (goog.isDef(data)) {
var featureObject =
/** @type {Object} */ (objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isObject(featureObject));
goog.asserts.assert(goog.isObject(featureObject),
'featureObject should be an Object');
featureObject[name] = data;
}
}
@@ -998,8 +1040,10 @@ ol.format.KML.DataParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.ExtendedDataParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ExtendedData');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ExtendedData',
'localName should be ExtendedData');
ol.xml.parseNode(ol.format.KML.EXTENDED_DATA_PARSERS_, node, objectStack);
};
@@ -1010,8 +1054,9 @@ ol.format.KML.ExtendedDataParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.PairDataParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Pair');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Pair', 'localName should be Pair');
var pairObject = ol.xml.pushParseAndPop(
{}, ol.format.KML.PAIR_PARSERS_, node, objectStack);
if (!goog.isDef(pairObject)) {
@@ -1040,20 +1085,23 @@ ol.format.KML.PairDataParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.PlacemarkStyleMapParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'StyleMap');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'StyleMap',
'localName should be StyleMap');
var styleMapValue = ol.format.KML.readStyleMapValue_(node, objectStack);
if (!goog.isDef(styleMapValue)) {
return;
}
var placemarkObject = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(placemarkObject));
goog.asserts.assert(goog.isObject(placemarkObject),
'placemarkObject should be an Object');
if (goog.isArray(styleMapValue)) {
placemarkObject['Style'] = styleMapValue;
} else if (goog.isString(styleMapValue)) {
placemarkObject['styleUrl'] = styleMapValue;
} else {
goog.asserts.fail();
goog.asserts.fail('styleMapValue has an unknown type');
}
};
@@ -1064,8 +1112,10 @@ ol.format.KML.PlacemarkStyleMapParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.SchemaDataParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'SchemaData');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'SchemaData',
'localName should be SchemaData');
ol.xml.parseNode(ol.format.KML.SCHEMA_DATA_PARSERS_, node, objectStack);
};
@@ -1076,8 +1126,10 @@ ol.format.KML.SchemaDataParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.SimpleDataParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'SimpleData');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'SimpleData',
'localName should be SimpleData');
var name = node.getAttribute('name');
if (!goog.isNull(name)) {
var data = ol.format.XSD.readString(node);
@@ -1094,16 +1146,20 @@ ol.format.KML.SimpleDataParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.innerBoundaryIsParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'innerBoundaryIs');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'innerBoundaryIs',
'localName should be innerBoundaryIs');
var flatLinearRing = ol.xml.pushParseAndPop(
/** @type {Array.<number>|undefined} */ (undefined),
ol.format.KML.INNER_BOUNDARY_IS_PARSERS_, node, objectStack);
if (goog.isDef(flatLinearRing)) {
var flatLinearRings = /** @type {Array.<Array.<number>>} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isArray(flatLinearRings));
goog.asserts.assert(flatLinearRings.length > 0);
goog.asserts.assert(goog.isArray(flatLinearRings),
'flatLinearRings should be an array');
goog.asserts.assert(flatLinearRings.length > 0,
'flatLinearRings array should not be empty');
flatLinearRings.push(flatLinearRing);
}
};
@@ -1115,16 +1171,20 @@ ol.format.KML.innerBoundaryIsParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.outerBoundaryIsParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'outerBoundaryIs');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'outerBoundaryIs',
'localName should be outerBoundaryIs');
var flatLinearRing = ol.xml.pushParseAndPop(
/** @type {Array.<number>|undefined} */ (undefined),
ol.format.KML.OUTER_BOUNDARY_IS_PARSERS_, node, objectStack);
if (goog.isDef(flatLinearRing)) {
var flatLinearRings = /** @type {Array.<Array.<number>>} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isArray(flatLinearRings));
goog.asserts.assert(flatLinearRings.length > 0);
goog.asserts.assert(goog.isArray(flatLinearRings),
'flatLinearRings should be an array');
goog.asserts.assert(flatLinearRings.length > 0,
'flatLinearRings array should not be empty');
flatLinearRings[0] = flatLinearRing;
}
};
@@ -1136,8 +1196,9 @@ ol.format.KML.outerBoundaryIsParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.LinkParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Link');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Link', 'localName should be Link');
ol.xml.parseNode(ol.format.KML.LINK_PARSERS_, node, objectStack);
};
@@ -1148,11 +1209,13 @@ ol.format.KML.LinkParser_ = function(node, objectStack) {
* @private
*/
ol.format.KML.whenParser_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'when');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'when', 'localName should be when');
var gxTrackObject = /** @type {ol.format.KMLGxTrackObject_} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isObject(gxTrackObject));
goog.asserts.assert(goog.isObject(gxTrackObject),
'gxTrackObject should be an Object');
var whens = gxTrackObject.whens;
var s = ol.xml.getAllTextContent(node, false);
var re =
@@ -1497,9 +1560,11 @@ ol.format.KML.prototype.getExtensions = function() {
* @return {Array.<ol.Feature>|undefined} Features.
*/
ol.format.KML.prototype.readDocumentOrFolder_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
var localName = ol.xml.getLocalName(node);
goog.asserts.assert(localName == 'Document' || localName == 'Folder');
goog.asserts.assert(localName == 'Document' || localName == 'Folder',
'localName should be Document or Folder');
// FIXME use scope somehow
var parsersNS = ol.xml.makeParsersNS(
ol.format.KML.NAMESPACE_URIS_, {
@@ -1525,8 +1590,10 @@ ol.format.KML.prototype.readDocumentOrFolder_ = function(node, objectStack) {
* @return {ol.Feature|undefined} Feature.
*/
ol.format.KML.prototype.readPlacemark_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Placemark');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Placemark',
'localName should be Placemark');
var object = ol.xml.pushParseAndPop({'geometry': null},
ol.format.KML.PLACEMARK_PARSERS_, node, objectStack);
if (!goog.isDef(object)) {
@@ -1555,8 +1622,9 @@ ol.format.KML.prototype.readPlacemark_ = function(node, objectStack) {
* @private
*/
ol.format.KML.prototype.readSharedStyle_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Style');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Style', 'localName should be Style');
var id = node.getAttribute('id');
if (!goog.isNull(id)) {
var style = ol.format.KML.readStyle_(node, objectStack);
@@ -1579,8 +1647,10 @@ ol.format.KML.prototype.readSharedStyle_ = function(node, objectStack) {
* @private
*/
ol.format.KML.prototype.readSharedStyleMap_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'StyleMap');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'StyleMap',
'localName should be StyleMap');
var id = node.getAttribute('id');
if (goog.isNull(id)) {
return;
@@ -1615,11 +1685,13 @@ ol.format.KML.prototype.readFeature;
* @inheritDoc
*/
ol.format.KML.prototype.readFeatureFromNode = function(node, opt_options) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
if (!goog.array.contains(ol.format.KML.NAMESPACE_URIS_, node.namespaceURI)) {
return null;
}
goog.asserts.assert(node.localName == 'Placemark');
goog.asserts.assert(node.localName == 'Placemark',
'localName should be Placemark');
var feature = this.readPlacemark_(
node, [this.getReadOptions(node, opt_options)]);
if (goog.isDef(feature)) {
@@ -1646,7 +1718,8 @@ ol.format.KML.prototype.readFeatures;
* @inheritDoc
*/
ol.format.KML.prototype.readFeaturesFromNode = function(node, opt_options) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
if (!goog.array.contains(ol.format.KML.NAMESPACE_URIS_, node.namespaceURI)) {
return [];
}
@@ -1699,7 +1772,7 @@ ol.format.KML.prototype.readName = function(source) {
var doc = ol.xml.parse(source);
return this.readNameFromDocument(doc);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown type for source');
return undefined;
}
};
@@ -1769,7 +1842,7 @@ ol.format.KML.prototype.readNetworkLinks = function(source) {
var doc = ol.xml.parse(source);
goog.array.extend(networkLinks, this.readNetworkLinksFromDocument(doc));
} else {
goog.asserts.fail();
goog.asserts.fail('unknown type for source');
}
return networkLinks;
};
@@ -1855,7 +1928,7 @@ ol.format.KML.writeColorTextNode_ = function(node, color) {
ol.format.KML.writeCoordinatesTextNode_ =
function(node, coordinates, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var layout = context['layout'];
var stride = context['stride'];
@@ -1868,7 +1941,7 @@ ol.format.KML.writeCoordinatesTextNode_ =
layout == ol.geom.GeometryLayout.XYZM) {
dimension = 3;
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown geometry layout');
}
var d, i;
@@ -2042,7 +2115,9 @@ ol.format.KML.writeMultiGeometry_ =
goog.asserts.assert(
(geometry instanceof ol.geom.MultiPoint) ||
(geometry instanceof ol.geom.MultiLineString) ||
(geometry instanceof ol.geom.MultiPolygon));
(geometry instanceof ol.geom.MultiPolygon),
'geometry should be one of: ol.geom.MultiPoint, ' +
'ol.geom.MultiLineString or ol.geom.MultiPolygon');
/** @type {ol.xml.NodeStackItem} */
var context = {node: node};
var type = geometry.getType();
@@ -2063,7 +2138,7 @@ ol.format.KML.writeMultiGeometry_ =
(/** @type {ol.geom.MultiPolygon} */ (geometry)).getPolygons();
factory = ol.format.KML.POLYGON_NODE_FACTORY_;
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown geometry type: ' + type);
}
ol.xml.pushSerializeAndPop(context,
ol.format.KML.MULTI_GEOMETRY_SERIALIZERS_, factory,
@@ -2144,7 +2219,9 @@ ol.format.KML.writePrimitiveGeometry_ = function(node, geometry, objectStack) {
goog.asserts.assert(
(geometry instanceof ol.geom.Point) ||
(geometry instanceof ol.geom.LineString) ||
(geometry instanceof ol.geom.LinearRing));
(geometry instanceof ol.geom.LinearRing),
'geometry should be one of ol.geom.Point, ol.geom.LineString ' +
'or ol.geom.LinearRing');
var flatCoordinates = geometry.getFlatCoordinates();
var /** @type {ol.xml.NodeStackItem} */ context = {node: node};
context['layout'] = geometry.getLayout();
@@ -2163,9 +2240,11 @@ ol.format.KML.writePrimitiveGeometry_ = function(node, geometry, objectStack) {
* @private
*/
ol.format.KML.writePolygon_ = function(node, polygon, objectStack) {
goog.asserts.assertInstanceof(polygon, ol.geom.Polygon);
goog.asserts.assertInstanceof(polygon, ol.geom.Polygon,
'polygon should be an ol.geom.Polygon');
var linearRings = polygon.getLinearRings();
goog.asserts.assert(linearRings.length > 0);
goog.asserts.assert(linearRings.length > 0,
'linearRings should not be empty');
var outerRing = linearRings.shift();
var /** @type {ol.xml.NodeStackItem} */ context = {node: node};
// inner rings
@@ -2558,9 +2637,11 @@ ol.format.KML.GX_NODE_FACTORY_ = function(value, objectStack, opt_nodeName) {
*/
ol.format.KML.DOCUMENT_NODE_FACTORY_ = function(value, objectStack,
opt_nodeName) {
goog.asserts.assertInstanceof(value, ol.Feature);
goog.asserts.assertInstanceof(value, ol.Feature,
'value should be an ol.Feature');
var parentNode = objectStack[objectStack.length - 1].node;
goog.asserts.assert(ol.xml.isNode(parentNode));
goog.asserts.assert(ol.xml.isNode(parentNode),
'parentNode should be an XML node');
return ol.xml.createElementNS(parentNode.namespaceURI, 'Placemark');
};
@@ -2576,9 +2657,11 @@ ol.format.KML.DOCUMENT_NODE_FACTORY_ = function(value, objectStack,
ol.format.KML.GEOMETRY_NODE_FACTORY_ = function(value, objectStack,
opt_nodeName) {
if (goog.isDefAndNotNull(value)) {
goog.asserts.assertInstanceof(value, ol.geom.Geometry);
goog.asserts.assertInstanceof(value, ol.geom.Geometry,
'value should be an ol.geom.Geometry');
var parentNode = objectStack[objectStack.length - 1].node;
goog.asserts.assert(ol.xml.isNode(parentNode));
goog.asserts.assert(ol.xml.isNode(parentNode),
'parentNode should be an XML node');
return ol.xml.createElementNS(parentNode.namespaceURI,
ol.format.KML.GEOMETRY_TYPE_TO_NODENAME_[value.getType()]);
}

23
src/ol/format/osmxmlformat.js
View File

@@ -58,8 +58,9 @@ ol.format.OSMXML.prototype.getExtensions = function() {
* @private
*/
ol.format.OSMXML.readNode_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'node');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'node', 'localName should be node');
var options = /** @type {olx.format.ReadOptions} */ (objectStack[0]);
var state = /** @type {Object} */ (objectStack[objectStack.length - 1]);
var id = node.getAttribute('id');
@@ -89,8 +90,9 @@ ol.format.OSMXML.readNode_ = function(node, objectStack) {
* @private
*/
ol.format.OSMXML.readWay_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'way');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'way', 'localName should be way');
var options = /** @type {olx.format.ReadOptions} */ (objectStack[0]);
var id = node.getAttribute('id');
var values = ol.xml.pushParseAndPop({
@@ -128,8 +130,9 @@ ol.format.OSMXML.readWay_ = function(node, objectStack) {
* @return {ol.Feature|undefined} Track.
*/
ol.format.OSMXML.readNd_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'nd');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'nd', 'localName should be nd');
var values = /** @type {Object} */ (objectStack[objectStack.length - 1]);
values.ndrefs.push(node.getAttribute('ref'));
};
@@ -142,8 +145,9 @@ ol.format.OSMXML.readNd_ = function(node, objectStack) {
* @return {ol.Feature|undefined} Track.
*/
ol.format.OSMXML.readTag_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'tag');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'tag', 'localName should be tag');
var values = /** @type {Object} */ (objectStack[objectStack.length - 1]);
values.tags[node.getAttribute('k')] = node.getAttribute('v');
};
@@ -210,7 +214,8 @@ ol.format.OSMXML.prototype.readFeatures;
* @inheritDoc
*/
ol.format.OSMXML.prototype.readFeaturesFromNode = function(node, opt_options) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
var options = this.getReadOptions(node, opt_options);
if (node.localName == 'osm') {
var state = ol.xml.pushParseAndPop({

87
src/ol/format/owsformat.js
View File

@@ -24,7 +24,8 @@ goog.inherits(ol.format.OWS, ol.format.XML);
* @return {Object} OWS object.
*/
ol.format.OWS.prototype.readFromDocument = function(doc) {
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT);
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT,
'doc.nodeType should be DOCUMENT');
for (var n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
if (n.nodeType == goog.dom.NodeType.ELEMENT) {
return this.readFromNode(n);
@@ -39,7 +40,8 @@ ol.format.OWS.prototype.readFromDocument = function(doc) {
* @return {Object} OWS object.
*/
ol.format.OWS.prototype.readFromNode = function(node) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
var owsObject = ol.xml.pushParseAndPop({},
ol.format.OWS.PARSERS_, node, []);
return goog.isDef(owsObject) ? owsObject : null;
@@ -53,8 +55,10 @@ ol.format.OWS.prototype.readFromNode = function(node) {
* @return {Object|undefined}
*/
ol.format.OWS.readAddress_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Address');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Address',
'localName should be Address');
return ol.xml.pushParseAndPop({},
ol.format.OWS.ADDRESS_PARSERS_, node, objectStack);
};
@@ -67,8 +71,10 @@ ol.format.OWS.readAddress_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readAllowedValues_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'AllowedValues');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'AllowedValues',
'localName should be AllowedValues');
return ol.xml.pushParseAndPop({},
ol.format.OWS.ALLOWED_VALUES_PARSERS_, node, objectStack);
};
@@ -81,8 +87,10 @@ ol.format.OWS.readAllowedValues_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readConstraint_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Constraint');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Constraint',
'localName should be Constraint');
var name = node.getAttribute('name');
if (!goog.isDef(name)) {
return undefined;
@@ -100,8 +108,10 @@ ol.format.OWS.readConstraint_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readContactInfo_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ContactInfo');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ContactInfo',
'localName should be ContactInfo');
return ol.xml.pushParseAndPop({},
ol.format.OWS.CONTACT_INFO_PARSERS_, node, objectStack);
};
@@ -114,8 +124,9 @@ ol.format.OWS.readContactInfo_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readDcp_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'DCP');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'DCP', 'localName should be DCP');
return ol.xml.pushParseAndPop({},
ol.format.OWS.DCP_PARSERS_, node, objectStack);
};
@@ -128,8 +139,9 @@ ol.format.OWS.readDcp_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readGet_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Get');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Get', 'localName should be Get');
var href = ol.format.XLink.readHref(node);
if (!goog.isDef(href)) {
return undefined;
@@ -146,8 +158,9 @@ ol.format.OWS.readGet_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readHttp_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'HTTP');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'HTTP', 'localName should be HTTP');
return ol.xml.pushParseAndPop({}, ol.format.OWS.HTTP_PARSERS_,
node, objectStack);
};
@@ -160,8 +173,10 @@ ol.format.OWS.readHttp_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readOperation_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Operation');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Operation',
'localName should be Operation');
var name = node.getAttribute('name');
var value = ol.xml.pushParseAndPop({},
ol.format.OWS.OPERATION_PARSERS_, node, objectStack);
@@ -170,7 +185,7 @@ ol.format.OWS.readOperation_ = function(node, objectStack) {
}
var object = /** @type {Object} */
(objectStack[objectStack.length - 1]);
goog.asserts.assert(goog.isObject(object));
goog.asserts.assert(goog.isObject(object), 'object should be an Object');
object[name] = value;
};
@@ -184,8 +199,10 @@ ol.format.OWS.readOperation_ = function(node, objectStack) {
*/
ol.format.OWS.readOperationsMetadata_ = function(node,
objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'OperationsMetadata');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'OperationsMetadata',
'localName should be OperationsMetadata');
return ol.xml.pushParseAndPop({},
ol.format.OWS.OPERATIONS_METADATA_PARSERS_, node,
objectStack);
@@ -199,8 +216,9 @@ ol.format.OWS.readOperationsMetadata_ = function(node,
* @return {Object|undefined}
*/
ol.format.OWS.readPhone_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Phone');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Phone', 'localName should be Phone');
return ol.xml.pushParseAndPop({},
ol.format.OWS.PHONE_PARSERS_, node, objectStack);
};
@@ -214,8 +232,10 @@ ol.format.OWS.readPhone_ = function(node, objectStack) {
*/
ol.format.OWS.readServiceIdentification_ = function(node,
objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ServiceIdentification');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ServiceIdentification',
'localName should be ServiceIdentification');
return ol.xml.pushParseAndPop(
{}, ol.format.OWS.SERVICE_IDENTIFICATION_PARSERS_, node,
objectStack);
@@ -229,8 +249,10 @@ ol.format.OWS.readServiceIdentification_ = function(node,
* @return {Object|undefined}
*/
ol.format.OWS.readServiceContact_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ServiceContact');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ServiceContact',
'localName should be ServiceContact');
return ol.xml.pushParseAndPop(
{}, ol.format.OWS.SERVICE_CONTACT_PARSERS_, node,
objectStack);
@@ -244,8 +266,10 @@ ol.format.OWS.readServiceContact_ = function(node, objectStack) {
* @return {Object|undefined}
*/
ol.format.OWS.readServiceProvider_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ServiceProvider');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ServiceProvider',
'localName should be ServiceProvider');
return ol.xml.pushParseAndPop(
{}, ol.format.OWS.SERVICE_PROVIDER_PARSERS_, node,
objectStack);
@@ -259,8 +283,9 @@ ol.format.OWS.readServiceProvider_ = function(node, objectStack) {
* @return {string|undefined}
*/
ol.format.OWS.readValue_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Value');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Value', 'localName should be Value');
return ol.format.XSD.readString(node);
};

8
src/ol/format/polylineformat.js
View File

@@ -358,7 +358,7 @@ ol.format.Polyline.prototype.writeFeatureText = function(feature, opt_options) {
if (goog.isDefAndNotNull(geometry)) {
return this.writeGeometryText(geometry, opt_options);
} else {
goog.asserts.fail();
goog.asserts.fail('geometry needs to be defined');
return '';
}
};
@@ -369,7 +369,8 @@ ol.format.Polyline.prototype.writeFeatureText = function(feature, opt_options) {
*/
ol.format.Polyline.prototype.writeFeaturesText =
function(features, opt_options) {
goog.asserts.assert(features.length == 1);
goog.asserts.assert(features.length == 1,
'features array should have 1 item');
return this.writeFeatureText(features[0], opt_options);
};
@@ -391,7 +392,8 @@ ol.format.Polyline.prototype.writeGeometry;
*/
ol.format.Polyline.prototype.writeGeometryText =
function(geometry, opt_options) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
geometry = /** @type {ol.geom.LineString} */
(ol.format.Feature.transformWithOptions(
geometry, true, this.adaptOptions(opt_options)));

3
src/ol/format/topojsonformat.js
View File

@@ -251,7 +251,8 @@ ol.format.TopoJSON.readFeatureFromGeometry_ = function(object, arcs,
var geometry;
var type = object.type;
var geometryReader = ol.format.TopoJSON.GEOMETRY_READERS_[type];
goog.asserts.assert(goog.isDef(geometryReader));
goog.asserts.assert(goog.isDef(geometryReader),
'geometryReader should be defined');
if ((type === 'Point') || (type === 'MultiPoint')) {
geometry = geometryReader(object, scale, translate);
} else {

46
src/ol/format/wfsformat.js
View File

@@ -153,7 +153,7 @@ ol.format.WFS.prototype.readTransactionResponse = function(source) {
var doc = ol.xml.parse(source);
return this.readTransactionResponseFromDocument(doc);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown source type');
return undefined;
}
};
@@ -176,7 +176,7 @@ ol.format.WFS.prototype.readFeatureCollectionMetadata = function(source) {
var doc = ol.xml.parse(source);
return this.readFeatureCollectionMetadataFromDocument(doc);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown source type');
return undefined;
}
};
@@ -189,7 +189,8 @@ ol.format.WFS.prototype.readFeatureCollectionMetadata = function(source) {
*/
ol.format.WFS.prototype.readFeatureCollectionMetadataFromDocument =
function(doc) {
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT);
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT,
'doc.nodeType should be DOCUMENT');
for (var n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
if (n.nodeType == goog.dom.NodeType.ELEMENT) {
return this.readFeatureCollectionMetadataFromNode(n);
@@ -218,8 +219,10 @@ ol.format.WFS.FEATURE_COLLECTION_PARSERS_ = {
* FeatureCollection metadata.
*/
ol.format.WFS.prototype.readFeatureCollectionMetadataFromNode = function(node) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'FeatureCollection');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'FeatureCollection',
'localName should be FeatureCollection');
var result = {};
var value = ol.format.XSD.readNonNegativeIntegerString(
node.getAttribute('numberOfFeatures'));
@@ -327,7 +330,8 @@ ol.format.WFS.TRANSACTION_RESPONSE_PARSERS_ = {
* @return {ol.format.WFS.TransactionResponse|undefined} Transaction response.
*/
ol.format.WFS.prototype.readTransactionResponseFromDocument = function(doc) {
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT);
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT,
'doc.nodeType should be DOCUMENT');
for (var n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
if (n.nodeType == goog.dom.NodeType.ELEMENT) {
return this.readTransactionResponseFromNode(n);
@@ -342,8 +346,10 @@ ol.format.WFS.prototype.readTransactionResponseFromDocument = function(doc) {
* @return {ol.format.WFS.TransactionResponse|undefined} Transaction response.
*/
ol.format.WFS.prototype.readTransactionResponseFromNode = function(node) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'TransactionResponse');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'TransactionResponse',
'localName should be TransactionResponse');
return ol.xml.pushParseAndPop(
/** @type {ol.format.WFS.TransactionResponse} */({}),
ol.format.WFS.TRANSACTION_RESPONSE_PARSERS_, node, []);
@@ -369,7 +375,7 @@ ol.format.WFS.QUERY_SERIALIZERS_ = {
*/
ol.format.WFS.writeFeature_ = function(node, feature, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featureType = context['featureType'];
var featureNS = context['featureNS'];
var child = ol.xml.createElementNS(featureNS, featureType);
@@ -401,7 +407,7 @@ ol.format.WFS.writeOgcFidFilter_ = function(node, fid, objectStack) {
*/
ol.format.WFS.writeDelete_ = function(node, feature, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featureType = context['featureType'];
var featurePrefix = context['featurePrefix'];
featurePrefix = goog.isDef(featurePrefix) ? featurePrefix :
@@ -425,7 +431,7 @@ ol.format.WFS.writeDelete_ = function(node, feature, objectStack) {
*/
ol.format.WFS.writeUpdate_ = function(node, feature, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featureType = context['featureType'];
var featurePrefix = context['featurePrefix'];
featurePrefix = goog.isDef(featurePrefix) ? featurePrefix :
@@ -520,7 +526,7 @@ ol.format.WFS.TRANSACTION_SERIALIZERS_ = {
*/
ol.format.WFS.writeQuery_ = function(node, featureType, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var featurePrefix = context['featurePrefix'];
var featureNS = context['featureNS'];
var propertyNames = context['propertyNames'];
@@ -571,7 +577,7 @@ ol.format.WFS.writeOgcPropertyName_ = function(node, value, objectStack) {
*/
ol.format.WFS.writeOgcBBOX_ = function(node, bbox, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var geometryName = context['geometryName'];
var bboxNode = ol.xml.createElementNS('http://www.opengis.net/ogc', 'BBOX');
node.appendChild(bboxNode);
@@ -600,7 +606,7 @@ ol.format.WFS.GETFEATURE_SERIALIZERS_ = {
*/
ol.format.WFS.writeGetFeature_ = function(node, featureTypes, objectStack) {
var context = objectStack[objectStack.length - 1];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context), 'context should be an Object');
var item = goog.object.clone(context);
item.node = node;
ol.xml.pushSerializeAndPop(item,
@@ -653,7 +659,8 @@ ol.format.WFS.prototype.writeGetFeature = function(options) {
propertyNames: goog.isDef(options.propertyNames) ?
options.propertyNames : []
};
goog.asserts.assert(goog.isArray(options.featureTypes));
goog.asserts.assert(goog.isArray(options.featureTypes),
'options.featureTypes should be an array');
ol.format.WFS.writeGetFeature_(node, options.featureTypes, [context]);
return node;
};
@@ -734,7 +741,8 @@ ol.format.WFS.prototype.readProjection;
* @inheritDoc
*/
ol.format.WFS.prototype.readProjectionFromDocument = function(doc) {
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT);
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT,
'doc.nodeType should be a DOCUMENT');
for (var n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
if (n.nodeType == goog.dom.NodeType.ELEMENT) {
return this.readProjectionFromNode(n);
@@ -748,8 +756,10 @@ ol.format.WFS.prototype.readProjectionFromDocument = function(doc) {
* @inheritDoc
*/
ol.format.WFS.prototype.readProjectionFromNode = function(node) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'FeatureCollection');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'FeatureCollection',
'localName should be FeatureCollection');
if (goog.isDefAndNotNull(node.firstElementChild) &&
goog.isDefAndNotNull(node.firstElementChild.firstElementChild)) {

6
src/ol/format/wktformat.js
View File

@@ -164,7 +164,8 @@ ol.format.WKT.encodeMultiPolygonGeometry_ = function(geom) {
ol.format.WKT.encode_ = function(geom) {
var type = geom.getType();
var geometryEncoder = ol.format.WKT.GeometryEncoder_[type];
goog.asserts.assert(goog.isDef(geometryEncoder));
goog.asserts.assert(goog.isDef(geometryEncoder),
'geometryEncoder should be defined');
var enc = geometryEncoder(geom);
type = type.toUpperCase();
if (enc.length === 0) {
@@ -568,7 +569,8 @@ ol.format.WKT.Parser.prototype.match = function(type) {
ol.format.WKT.Parser.prototype.parse = function() {
this.consume_();
var geometry = this.parseGeometry_();
goog.asserts.assert(this.token_.type == ol.format.WKT.TokenType.EOF);
goog.asserts.assert(this.token_.type == ol.format.WKT.TokenType.EOF,
'token type should be end of file');
return geometry;
};

130
src/ol/format/wmscapabilitiesformat.js
View File

@@ -48,7 +48,8 @@ ol.format.WMSCapabilities.prototype.read;
* @return {Object} WMS Capability object.
*/
ol.format.WMSCapabilities.prototype.readFromDocument = function(doc) {
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT);
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT,
'doc.nodeType should be DOCUMENT');
for (var n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
if (n.nodeType == goog.dom.NodeType.ELEMENT) {
return this.readFromNode(n);
@@ -63,11 +64,13 @@ ol.format.WMSCapabilities.prototype.readFromDocument = function(doc) {
* @return {Object} WMS Capability object.
*/
ol.format.WMSCapabilities.prototype.readFromNode = function(node) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'WMS_Capabilities' ||
node.localName == 'WMT_MS_Capabilities');
node.localName == 'WMT_MS_Capabilities',
'localName should be WMS_Capabilities or WMT_MS_Capabilities');
this.version = goog.string.trim(node.getAttribute('version'));
goog.asserts.assertString(this.version);
goog.asserts.assertString(this.version, 'this.version should be a string');
var wmsCapabilityObject = ol.xml.pushParseAndPop({
'version': this.version
}, ol.format.WMSCapabilities.PARSERS_, node, []);
@@ -82,8 +85,10 @@ ol.format.WMSCapabilities.prototype.readFromNode = function(node) {
* @return {Object|undefined} Attribution object.
*/
ol.format.WMSCapabilities.readAttribution_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Attribution');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Attribution',
'localName should be Attribution');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.ATTRIBUTION_PARSERS_, node, objectStack);
};
@@ -96,8 +101,10 @@ ol.format.WMSCapabilities.readAttribution_ = function(node, objectStack) {
* @return {Object} Bounding box object.
*/
ol.format.WMSCapabilities.readBoundingBox_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'BoundingBox');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'BoundingBox',
'localName should be BoundingBox');
var extent = [
ol.format.XSD.readDecimalString(node.getAttribute('minx')),
@@ -127,8 +134,10 @@ ol.format.WMSCapabilities.readBoundingBox_ = function(node, objectStack) {
*/
ol.format.WMSCapabilities.readEXGeographicBoundingBox_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'EX_GeographicBoundingBox');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'EX_GeographicBoundingBox',
'localName should be EX_GeographicBoundingBox');
var geographicBoundingBox = ol.xml.pushParseAndPop(
{},
ol.format.WMSCapabilities.EX_GEOGRAPHIC_BOUNDING_BOX_PARSERS_,
@@ -162,8 +171,10 @@ ol.format.WMSCapabilities.readEXGeographicBoundingBox_ =
* @return {Object|undefined} Capability object.
*/
ol.format.WMSCapabilities.readCapability_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Capability');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Capability',
'localName should be Capability');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.CAPABILITY_PARSERS_, node, objectStack);
};
@@ -176,8 +187,10 @@ ol.format.WMSCapabilities.readCapability_ = function(node, objectStack) {
* @return {Object|undefined} Service object.
*/
ol.format.WMSCapabilities.readService_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Service');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Service',
'localName should be Service');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.SERVICE_PARSERS_, node, objectStack);
};
@@ -191,8 +204,10 @@ ol.format.WMSCapabilities.readService_ = function(node, objectStack) {
*/
ol.format.WMSCapabilities.readContactInformation_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ContactInformation');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType shpuld be ELEMENT');
goog.asserts.assert(node.localName == 'ContactInformation',
'localName should be ContactInformation');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.CONTACT_INFORMATION_PARSERS_,
node, objectStack);
@@ -207,8 +222,10 @@ ol.format.WMSCapabilities.readContactInformation_ =
*/
ol.format.WMSCapabilities.readContactPersonPrimary_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ContactPersonPrimary');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ContactPersonPrimary',
'localName should be ContactPersonPrimary');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.CONTACT_PERSON_PARSERS_,
node, objectStack);
@@ -223,8 +240,10 @@ ol.format.WMSCapabilities.readContactPersonPrimary_ =
*/
ol.format.WMSCapabilities.readContactAddress_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'ContactAddress');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'ContactAddress',
'localName should be ContactAddress');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.CONTACT_ADDRESS_PARSERS_,
node, objectStack);
@@ -238,8 +257,10 @@ ol.format.WMSCapabilities.readContactAddress_ =
* @return {Array.<string>|undefined} Format array.
*/
ol.format.WMSCapabilities.readException_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Exception');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Exception',
'localName should be Exception');
return ol.xml.pushParseAndPop(
[], ol.format.WMSCapabilities.EXCEPTION_PARSERS_, node, objectStack);
};
@@ -252,8 +273,9 @@ ol.format.WMSCapabilities.readException_ = function(node, objectStack) {
* @return {Object|undefined} Layer object.
*/
ol.format.WMSCapabilities.readCapabilityLayer_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Layer');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Layer', 'localName should be Layer');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.LAYER_PARSERS_, node, objectStack);
};
@@ -266,8 +288,9 @@ ol.format.WMSCapabilities.readCapabilityLayer_ = function(node, objectStack) {
* @return {Object|undefined} Layer object.
*/
ol.format.WMSCapabilities.readLayer_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Layer');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Layer', 'localName should be Layer');
var parentLayerObject = /** @type {Object.<string,*>} */
(objectStack[objectStack.length - 1]);
@@ -350,8 +373,10 @@ ol.format.WMSCapabilities.readLayer_ = function(node, objectStack) {
* @return {Object} Dimension object.
*/
ol.format.WMSCapabilities.readDimension_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Dimension');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Dimension',
'localName should be Dimension');
var dimensionObject = {
'name': node.getAttribute('name'),
'units': node.getAttribute('units'),
@@ -376,7 +401,8 @@ ol.format.WMSCapabilities.readDimension_ = function(node, objectStack) {
*/
ol.format.WMSCapabilities.readFormatOnlineresource_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.FORMAT_ONLINERESOURCE_PARSERS_,
node, objectStack);
@@ -390,8 +416,10 @@ ol.format.WMSCapabilities.readFormatOnlineresource_ =
* @return {Object|undefined} Request object.
*/
ol.format.WMSCapabilities.readRequest_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Request');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Request',
'localName should be Request');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.REQUEST_PARSERS_, node, objectStack);
};
@@ -404,8 +432,10 @@ ol.format.WMSCapabilities.readRequest_ = function(node, objectStack) {
* @return {Object|undefined} DCP type object.
*/
ol.format.WMSCapabilities.readDCPType_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'DCPType');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'DCPType',
'localName should be DCPType');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.DCPTYPE_PARSERS_, node, objectStack);
};
@@ -418,8 +448,9 @@ ol.format.WMSCapabilities.readDCPType_ = function(node, objectStack) {
* @return {Object|undefined} HTTP object.
*/
ol.format.WMSCapabilities.readHTTP_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'HTTP');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'HTTP', 'localName should be HTTP');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.HTTP_PARSERS_, node, objectStack);
};
@@ -432,7 +463,8 @@ ol.format.WMSCapabilities.readHTTP_ = function(node, objectStack) {
* @return {Object|undefined} Operation type object.
*/
ol.format.WMSCapabilities.readOperationType_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.OPERATIONTYPE_PARSERS_, node, objectStack);
};
@@ -446,7 +478,8 @@ ol.format.WMSCapabilities.readOperationType_ = function(node, objectStack) {
*/
ol.format.WMSCapabilities.readSizedFormatOnlineresource_ =
function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
var formatOnlineresource =
ol.format.WMSCapabilities.readFormatOnlineresource_(node, objectStack);
if (goog.isDef(formatOnlineresource)) {
@@ -468,8 +501,10 @@ ol.format.WMSCapabilities.readSizedFormatOnlineresource_ =
* @return {Object|undefined} Authority URL object.
*/
ol.format.WMSCapabilities.readAuthorityURL_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'AuthorityURL');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'AuthorityURL',
'localName should be AuthorityURL');
var authorityObject =
ol.format.WMSCapabilities.readFormatOnlineresource_(node, objectStack);
if (goog.isDef(authorityObject)) {
@@ -487,8 +522,10 @@ ol.format.WMSCapabilities.readAuthorityURL_ = function(node, objectStack) {
* @return {Object|undefined} Metadata URL object.
*/
ol.format.WMSCapabilities.readMetadataURL_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'MetadataURL');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'MetadataURL',
'localName should be MetadataURL');
var metadataObject =
ol.format.WMSCapabilities.readFormatOnlineresource_(node, objectStack);
if (goog.isDef(metadataObject)) {
@@ -506,8 +543,9 @@ ol.format.WMSCapabilities.readMetadataURL_ = function(node, objectStack) {
* @return {Object|undefined} Style object.
*/
ol.format.WMSCapabilities.readStyle_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Style');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Style', 'localName should be Style');
return ol.xml.pushParseAndPop(
{}, ol.format.WMSCapabilities.STYLE_PARSERS_, node, objectStack);
};
@@ -520,8 +558,10 @@ ol.format.WMSCapabilities.readStyle_ = function(node, objectStack) {
* @return {Array.<string>|undefined} Keyword list.
*/
ol.format.WMSCapabilities.readKeywordList_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'KeywordList');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'KeywordList',
'localName should be KeywordList');
return ol.xml.pushParseAndPop(
[], ol.format.WMSCapabilities.KEYWORDLIST_PARSERS_, node, objectStack);
};

9
src/ol/format/wmsgetfeatureinfoformat.js
View File

@@ -67,7 +67,8 @@ ol.format.WMSGetFeatureInfo.prototype.readFeatures_ =
function(node, objectStack) {
node.namespaceURI = this.featureNS_;
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
var localName = ol.xml.getLocalName(node);
/** @type {Array.<ol.Feature>} */
var features = [];
@@ -80,10 +81,12 @@ ol.format.WMSGetFeatureInfo.prototype.readFeatures_ =
return;
}
var context = objectStack[0];
goog.asserts.assert(goog.isObject(context));
goog.asserts.assert(goog.isObject(context),
'context should be an Object');
goog.asserts.assert(layer.localName.indexOf(
ol.format.WMSGetFeatureInfo.layerIdentifier_) >= 0);
ol.format.WMSGetFeatureInfo.layerIdentifier_) >= 0,
'localName of layer node should match layerIdentifier');
var featureType = goog.string.remove(layer.localName,
ol.format.WMSGetFeatureInfo.layerIdentifier_) +

22
src/ol/format/wmtscapabilitiesformat.js
View File

@@ -49,7 +49,8 @@ ol.format.WMTSCapabilities.prototype.read;
* @return {Object} WMTS Capability object.
*/
ol.format.WMTSCapabilities.prototype.readFromDocument = function(doc) {
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT);
goog.asserts.assert(doc.nodeType == goog.dom.NodeType.DOCUMENT,
'doc.nodeType should be DOCUMENT');
for (var n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
if (n.nodeType == goog.dom.NodeType.ELEMENT) {
return this.readFromNode(n);
@@ -64,10 +65,12 @@ ol.format.WMTSCapabilities.prototype.readFromDocument = function(doc) {
* @return {Object} WMTS Capability object.
*/
ol.format.WMTSCapabilities.prototype.readFromNode = function(node) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Capabilities');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Capabilities',
'localName should be Capabilities');
this.version = goog.string.trim(node.getAttribute('version'));
goog.asserts.assertString(this.version);
goog.asserts.assertString(this.version, 'this.version should be a string');
var WMTSCapabilityObject = this.owsParser_.readFromNode(node);
if (!goog.isDef(WMTSCapabilityObject)) {
return null;
@@ -86,8 +89,10 @@ ol.format.WMTSCapabilities.prototype.readFromNode = function(node) {
* @return {Object|undefined} Attribution object.
*/
ol.format.WMTSCapabilities.readContents_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Contents');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Contents',
'localName should be Contents');
return ol.xml.pushParseAndPop({},
ol.format.WMTSCapabilities.CONTENTS_PARSERS_, node, objectStack);
@@ -101,8 +106,9 @@ ol.format.WMTSCapabilities.readContents_ = function(node, objectStack) {
* @return {Object|undefined} Layers object.
*/
ol.format.WMTSCapabilities.readLayer_ = function(node, objectStack) {
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.localName == 'Layer');
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
goog.asserts.assert(node.localName == 'Layer', 'localName should be Layer');
return ol.xml.pushParseAndPop({},
ol.format.WMTSCapabilities.LAYER_PARSERS_, node, objectStack);
};

17
src/ol/format/xmlfeatureformat.js
View File

@@ -47,7 +47,7 @@ ol.format.XMLFeature.prototype.readFeature = function(source, opt_options) {
var doc = ol.xml.parse(source);
return this.readFeatureFromDocument(doc, opt_options);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown source type');
return null;
}
};
@@ -90,7 +90,7 @@ ol.format.XMLFeature.prototype.readFeatures = function(source, opt_options) {
var doc = ol.xml.parse(source);
return this.readFeaturesFromDocument(doc, opt_options);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown source type');
return [];
}
};
@@ -138,7 +138,7 @@ ol.format.XMLFeature.prototype.readGeometry = function(source, opt_options) {
var doc = ol.xml.parse(source);
return this.readGeometryFromDocument(doc, opt_options);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown source type');
return null;
}
};
@@ -174,7 +174,7 @@ ol.format.XMLFeature.prototype.readProjection = function(source) {
var doc = ol.xml.parse(source);
return this.readProjectionFromDocument(doc);
} else {
goog.asserts.fail();
goog.asserts.fail('Unknown source type');
return null;
}
};
@@ -205,7 +205,8 @@ ol.format.XMLFeature.prototype.readProjectionFromNode = function(node) {
*/
ol.format.XMLFeature.prototype.writeFeature = function(feature, opt_options) {
var node = this.writeFeatureNode(feature, opt_options);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return goog.dom.xml.serialize(/** @type {Element} */(node));
};
@@ -224,7 +225,8 @@ ol.format.XMLFeature.prototype.writeFeatureNode = goog.abstractMethod;
*/
ol.format.XMLFeature.prototype.writeFeatures = function(features, opt_options) {
var node = this.writeFeaturesNode(features, opt_options);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return goog.dom.xml.serialize(/** @type {Element} */(node));
};
@@ -242,7 +244,8 @@ ol.format.XMLFeature.prototype.writeFeaturesNode = goog.abstractMethod;
*/
ol.format.XMLFeature.prototype.writeGeometry = function(geometry, opt_options) {
var node = this.writeGeometryNode(geometry, opt_options);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT,
'node.nodeType should be ELEMENT');
return goog.dom.xml.serialize(/** @type {Element} */(node));
};

5
src/ol/format/xsdformat.js
View File

@@ -167,8 +167,9 @@ ol.format.XSD.writeDecimalTextNode = function(node, decimal) {
*/
ol.format.XSD.writeNonNegativeIntegerTextNode =
function(node, nonNegativeInteger) {
goog.asserts.assert(nonNegativeInteger >= 0);
goog.asserts.assert(nonNegativeInteger == (nonNegativeInteger | 0));
goog.asserts.assert(nonNegativeInteger >= 0, 'value should be more than 0');
goog.asserts.assert(nonNegativeInteger == (nonNegativeInteger | 0),
'value should be an integer value');
var string = nonNegativeInteger.toString();
node.appendChild(ol.xml.DOCUMENT.createTextNode(string));
};

6
src/ol/geom/circle.js
View File

@@ -140,7 +140,8 @@ ol.geom.Circle.prototype.getType = function() {
*/
ol.geom.Circle.prototype.setCenter = function(center) {
var stride = this.stride;
goog.asserts.assert(center.length == stride);
goog.asserts.assert(center.length == stride,
'center array length should match stride');
var radius = this.flatCoordinates[stride] - this.flatCoordinates[0];
var flatCoordinates = center.slice();
flatCoordinates[stride] = flatCoordinates[0] + radius;
@@ -199,7 +200,8 @@ ol.geom.Circle.prototype.setFlatCoordinates =
* @api
*/
ol.geom.Circle.prototype.setRadius = function(radius) {
goog.asserts.assert(!goog.isNull(this.flatCoordinates));
goog.asserts.assert(!goog.isNull(this.flatCoordinates),
'this.flatCoordinates cannot be null');
this.flatCoordinates[this.stride] = this.flatCoordinates[0] + radius;
this.changed();
};

2
src/ol/geom/flat/closestflatgeom.js
View File

@@ -153,7 +153,7 @@ ol.geom.flat.closest.getClosestPoint = function(flatCoordinates, offset, end,
return minSquaredDistance;
}
}
goog.asserts.assert(maxDelta > 0);
goog.asserts.assert(maxDelta > 0, 'maxDelta should be larger than 0');
var tmpPoint = goog.isDef(opt_tmpPoint) ? opt_tmpPoint : [NaN, NaN];
var index = offset + stride;
while (index < end) {

4
src/ol/geom/flat/containsflatgeom.js
View File

@@ -67,7 +67,7 @@ ol.geom.flat.contains.linearRingContainsXY =
*/
ol.geom.flat.contains.linearRingsContainsXY =
function(flatCoordinates, offset, ends, stride, x, y) {
goog.asserts.assert(ends.length > 0);
goog.asserts.assert(ends.length > 0, 'ends should not be an empty array');
if (ends.length === 0) {
return false;
}
@@ -97,7 +97,7 @@ ol.geom.flat.contains.linearRingsContainsXY =
*/
ol.geom.flat.contains.linearRingssContainsXY =
function(flatCoordinates, offset, endss, stride, x, y) {
goog.asserts.assert(endss.length > 0);
goog.asserts.assert(endss.length > 0, 'endss should not be an empty array');
if (endss.length === 0) {
return false;
}

6
src/ol/geom/flat/deflateflatgeom.js
View File

@@ -12,7 +12,8 @@ goog.require('goog.asserts');
*/
ol.geom.flat.deflate.coordinate =
function(flatCoordinates, offset, coordinate, stride) {
goog.asserts.assert(coordinate.length == stride);
goog.asserts.assert(coordinate.length == stride,
'length of the coordinate array should match stride');
var i, ii;
for (i = 0, ii = coordinate.length; i < ii; ++i) {
flatCoordinates[offset++] = coordinate[i];
@@ -33,7 +34,8 @@ ol.geom.flat.deflate.coordinates =
var i, ii;
for (i = 0, ii = coordinates.length; i < ii; ++i) {
var coordinate = coordinates[i];
goog.asserts.assert(coordinate.length == stride);
goog.asserts.assert(coordinate.length == stride,
'length of coordinate array should match stride');
var j;
for (j = 0; j < stride; ++j) {
flatCoordinates[offset++] = coordinate[j];

3
src/ol/geom/flat/flipflatgeom.js
View File

@@ -19,7 +19,8 @@ ol.geom.flat.flip.flipXY =
dest = opt_dest;
destOffset = goog.isDef(opt_destOffset) ? opt_destOffset : 0;
} else {
goog.asserts.assert(!goog.isDef(opt_destOffset));
goog.asserts.assert(!goog.isDef(opt_destOffset),
'opt_destOffSet should be defined');
dest = [];
destOffset = 0;
}

6
src/ol/geom/flat/geodesicflatgeom.js
View File

@@ -69,7 +69,8 @@ ol.geom.flat.geodesic.line_ =
// segment.
flatCoordinates.push(b[0], b[1]);
key = fracB.toString();
goog.asserts.assert(!goog.object.containsKey(fractions, key));
goog.asserts.assert(!goog.object.containsKey(fractions, key),
'fractions object should contain key : ' + key);
fractions[key] = true;
} else {
// Otherwise, we need to subdivide the current line segment. Split it
@@ -79,7 +80,8 @@ ol.geom.flat.geodesic.line_ =
geoStack.push(geoB, geoM, geoM, geoA);
}
}
goog.asserts.assert(maxIterations > 0);
goog.asserts.assert(maxIterations > 0,
'maxIterations should be more than 0');
return flatCoordinates;
};

3
src/ol/geom/flat/interiorpointflatgeom.js
View File

@@ -79,7 +79,8 @@ ol.geom.flat.interiorpoint.linearRings = function(flatCoordinates, offset,
*/
ol.geom.flat.interiorpoint.linearRingss =
function(flatCoordinates, offset, endss, stride, flatCenters) {
goog.asserts.assert(2 * endss.length == flatCenters.length);
goog.asserts.assert(2 * endss.length == flatCenters.length,
'endss.length times 2 should be flatCenters.length');
var interiorPoints = [];
var i, ii;
for (i = 0, ii = endss.length; i < ii; ++i) {

15
src/ol/geom/flat/interpolateflatgeom.js
View File

@@ -17,12 +17,13 @@ goog.require('goog.math');
ol.geom.flat.interpolate.lineString =
function(flatCoordinates, offset, end, stride, fraction, opt_dest) {
// FIXME interpolate extra dimensions
goog.asserts.assert(0 <= fraction && fraction <= 1);
goog.asserts.assert(0 <= fraction && fraction <= 1,
'fraction should be in between 0 and 1');
var pointX = NaN;
var pointY = NaN;
var n = (end - offset) / stride;
if (n === 0) {
goog.asserts.fail();
goog.asserts.fail('n cannot be 0');
} else if (n == 1) {
pointX = flatCoordinates[offset];
pointY = flatCoordinates[offset + 1];
@@ -121,8 +122,8 @@ ol.geom.flat.lineStringCoordinateAtM =
return flatCoordinates.slice((lo - 1) * stride, (lo - 1) * stride + stride);
}
var m1 = flatCoordinates[(lo + 1) * stride - 1];
goog.asserts.assert(m0 < m);
goog.asserts.assert(m <= m1);
goog.asserts.assert(m0 < m, 'm0 should be less than m');
goog.asserts.assert(m <= m1, 'm should be less than or equal to m1');
var t = (m - m0) / (m1 - m0);
coordinate = [];
var i;
@@ -131,7 +132,8 @@ ol.geom.flat.lineStringCoordinateAtM =
flatCoordinates[lo * stride + i], t));
}
coordinate.push(m);
goog.asserts.assert(coordinate.length == stride);
goog.asserts.assert(coordinate.length == stride,
'length of coordinate array should match stride');
return coordinate;
};
@@ -185,6 +187,7 @@ ol.geom.flat.lineStringsCoordinateAtM = function(
}
offset = end;
}
goog.asserts.fail();
goog.asserts.fail(
'ol.geom.flat.lineStringsCoordinateAtM should have returned');
return null;
};

4
src/ol/geom/flat/intersectsextent.js
View File

@@ -111,7 +111,7 @@ ol.geom.flat.intersectsextent.linearRing =
*/
ol.geom.flat.intersectsextent.linearRings =
function(flatCoordinates, offset, ends, stride, extent) {
goog.asserts.assert(ends.length > 0);
goog.asserts.assert(ends.length > 0, 'ends should not be an empty array');
if (!ol.geom.flat.intersectsextent.linearRing(
flatCoordinates, offset, ends[0], stride, extent)) {
return false;
@@ -140,7 +140,7 @@ ol.geom.flat.intersectsextent.linearRings =
*/
ol.geom.flat.intersectsextent.linearRingss =
function(flatCoordinates, offset, endss, stride, extent) {
goog.asserts.assert(endss.length > 0);
goog.asserts.assert(endss.length > 0, 'endss should not be an empty array');
var i, ii;
for (i = 0, ii = endss.length; i < ii; ++i) {
var ends = endss[i];

3
src/ol/geom/linestring.js
View File

@@ -66,7 +66,8 @@ goog.inherits(ol.geom.LineString, ol.geom.SimpleGeometry);
* @api stable
*/
ol.geom.LineString.prototype.appendCoordinate = function(coordinate) {
goog.asserts.assert(coordinate.length == this.stride);
goog.asserts.assert(coordinate.length == this.stride,
'length of coordinate array should match stride');
if (goog.isNull(this.flatCoordinates)) {
this.flatCoordinates = coordinate.slice();
} else {

18
src/ol/geom/multilinestring.js
View File

@@ -59,7 +59,8 @@ goog.inherits(ol.geom.MultiLineString, ol.geom.SimpleGeometry);
* @api stable
*/
ol.geom.MultiLineString.prototype.appendLineString = function(lineString) {
goog.asserts.assert(lineString.getLayout() == this.layout);
goog.asserts.assert(lineString.getLayout() == this.layout,
'layout of lineString should match the layout');
if (goog.isNull(this.flatCoordinates)) {
this.flatCoordinates = lineString.getFlatCoordinates().slice();
} else {
@@ -164,7 +165,8 @@ ol.geom.MultiLineString.prototype.getEnds = function() {
* @api stable
*/
ol.geom.MultiLineString.prototype.getLineString = function(index) {
goog.asserts.assert(0 <= index && index < this.ends_.length);
goog.asserts.assert(0 <= index && index < this.ends_.length,
'index should be in between 0 and length of the this.ends_ array');
if (index < 0 || this.ends_.length <= index) {
return null;
}
@@ -285,11 +287,14 @@ ol.geom.MultiLineString.prototype.setCoordinates =
ol.geom.MultiLineString.prototype.setFlatCoordinates =
function(layout, flatCoordinates, ends) {
if (goog.isNull(flatCoordinates)) {
goog.asserts.assert(!goog.isNull(ends) && ends.length === 0);
goog.asserts.assert(!goog.isNull(ends) && ends.length === 0,
'ends cannot be null and ends.length should be 0');
} else if (ends.length === 0) {
goog.asserts.assert(flatCoordinates.length === 0);
goog.asserts.assert(flatCoordinates.length === 0,
'flatCoordinates should be an empty array');
} else {
goog.asserts.assert(flatCoordinates.length == ends[ends.length - 1]);
goog.asserts.assert(flatCoordinates.length == ends[ends.length - 1],
'length of flatCoordinates array should match the last value of ends');
}
this.setFlatCoordinatesInternal(layout, flatCoordinates);
this.ends_ = ends;
@@ -311,7 +316,8 @@ ol.geom.MultiLineString.prototype.setLineStrings = function(lineStrings) {
layout = lineString.getLayout();
} else {
// FIXME better handle the case of non-matching layouts
goog.asserts.assert(lineString.getLayout() == layout);
goog.asserts.assert(lineString.getLayout() == layout,
'layout of lineString should match layout');
}
goog.array.extend(flatCoordinates, lineString.getFlatCoordinates());
ends.push(flatCoordinates.length);

6
src/ol/geom/multipoint.js
View File

@@ -35,7 +35,8 @@ goog.inherits(ol.geom.MultiPoint, ol.geom.SimpleGeometry);
* @api stable
*/
ol.geom.MultiPoint.prototype.appendPoint = function(point) {
goog.asserts.assert(point.getLayout() == this.layout);
goog.asserts.assert(point.getLayout() == this.layout,
'the layout of point should match layout');
if (goog.isNull(this.flatCoordinates)) {
this.flatCoordinates = point.getFlatCoordinates().slice();
} else {
@@ -102,7 +103,8 @@ ol.geom.MultiPoint.prototype.getCoordinates = function() {
ol.geom.MultiPoint.prototype.getPoint = function(index) {
var n = goog.isNull(this.flatCoordinates) ?
0 : this.flatCoordinates.length / this.stride;
goog.asserts.assert(0 <= index && index < n);
goog.asserts.assert(0 <= index && index < n,
'index should be in between 0 and n');
if (index < 0 || n <= index) {
return null;
}

18
src/ol/geom/multipolygon.js
View File

@@ -88,7 +88,8 @@ goog.inherits(ol.geom.MultiPolygon, ol.geom.SimpleGeometry);
* @api stable
*/
ol.geom.MultiPolygon.prototype.appendPolygon = function(polygon) {
goog.asserts.assert(polygon.getLayout() == this.layout);
goog.asserts.assert(polygon.getLayout() == this.layout,
'layout of polygon should match layout');
/** @type {Array.<number>} */
var ends;
if (goog.isNull(this.flatCoordinates)) {
@@ -270,7 +271,8 @@ ol.geom.MultiPolygon.prototype.getSimplifiedGeometryInternal =
* @api stable
*/
ol.geom.MultiPolygon.prototype.getPolygon = function(index) {
goog.asserts.assert(0 <= index && index < this.endss_.length);
goog.asserts.assert(0 <= index && index < this.endss_.length,
'index should be in between 0 and the length of this.endss_');
if (index < 0 || this.endss_.length <= index) {
return null;
}
@@ -379,13 +381,14 @@ ol.geom.MultiPolygon.prototype.setCoordinates =
*/
ol.geom.MultiPolygon.prototype.setFlatCoordinates =
function(layout, flatCoordinates, endss) {
goog.asserts.assert(!goog.isNull(endss));
goog.asserts.assert(!goog.isNull(endss), 'endss cannot be null');
if (goog.isNull(flatCoordinates) || flatCoordinates.length === 0) {
goog.asserts.assert(endss.length === 0);
goog.asserts.assert(endss.length === 0, 'the length of endss should be 0');
} else {
goog.asserts.assert(endss.length > 0);
goog.asserts.assert(endss.length > 0, 'endss cannot be an empty array');
var ends = endss[endss.length - 1];
goog.asserts.assert(flatCoordinates.length == ends[ends.length - 1]);
goog.asserts.assert(flatCoordinates.length == ends[ends.length - 1],
'the length of flatCoordinates should be the last value of ends');
}
this.setFlatCoordinatesInternal(layout, flatCoordinates);
this.endss_ = endss;
@@ -407,7 +410,8 @@ ol.geom.MultiPolygon.prototype.setPolygons = function(polygons) {
layout = polygon.getLayout();
} else {
// FIXME better handle the case of non-matching layouts
goog.asserts.assert(polygon.getLayout() == layout);
goog.asserts.assert(polygon.getLayout() == layout,
'layout of polygon should be layout');
}
var offset = flatCoordinates.length;
ends = polygon.getEnds();

15
src/ol/geom/polygon.js
View File

@@ -87,7 +87,8 @@ goog.inherits(ol.geom.Polygon, ol.geom.SimpleGeometry);
* @api stable
*/
ol.geom.Polygon.prototype.appendLinearRing = function(linearRing) {
goog.asserts.assert(linearRing.getLayout() == this.layout);
goog.asserts.assert(linearRing.getLayout() == this.layout,
'layout of linearRing should match layout');
if (goog.isNull(this.flatCoordinates)) {
this.flatCoordinates = linearRing.getFlatCoordinates().slice();
} else {
@@ -233,7 +234,8 @@ ol.geom.Polygon.prototype.getLinearRingCount = function() {
* @api stable
*/
ol.geom.Polygon.prototype.getLinearRing = function(index) {
goog.asserts.assert(0 <= index && index < this.ends_.length);
goog.asserts.assert(0 <= index && index < this.ends_.length,
'index should be in between 0 and and length of this.ends_');
if (index < 0 || this.ends_.length <= index) {
return null;
}
@@ -353,11 +355,14 @@ ol.geom.Polygon.prototype.setCoordinates = function(coordinates, opt_layout) {
ol.geom.Polygon.prototype.setFlatCoordinates =
function(layout, flatCoordinates, ends) {
if (goog.isNull(flatCoordinates)) {
goog.asserts.assert(!goog.isNull(ends) && ends.length === 0);
goog.asserts.assert(!goog.isNull(ends) && ends.length === 0,
'ends cannot be null and should be an empty array');
} else if (ends.length === 0) {
goog.asserts.assert(flatCoordinates.length === 0);
goog.asserts.assert(flatCoordinates.length === 0,
'flatCoordinates should be an empty array');
} else {
goog.asserts.assert(flatCoordinates.length == ends[ends.length - 1]);
goog.asserts.assert(flatCoordinates.length == ends[ends.length - 1],
'the length of flatCoordinates should be the last entry of ends');
}
this.setFlatCoordinatesInternal(layout, flatCoordinates);
this.ends_ = ends;

33
src/ol/graticule.js
View File

@@ -68,7 +68,8 @@ ol.Graticule = function(opt_options) {
* @private
*/
this.maxLines_ = goog.isDef(options.maxLines) ? options.maxLines : 100;
goog.asserts.assert(this.maxLines_ > 0);
goog.asserts.assert(this.maxLines_ > 0,
'this.maxLines_ should be more than 0');
/**
* @type {Array.<ol.geom.LineString>}
@@ -287,11 +288,14 @@ ol.Graticule.prototype.getMap = function() {
* @private
*/
ol.Graticule.prototype.getMeridian_ = function(lon, squaredTolerance, index) {
goog.asserts.assert(lon >= this.minLon_);
goog.asserts.assert(lon <= this.maxLon_);
goog.asserts.assert(lon >= this.minLon_,
'lon should be larger than or equal to this.minLon_');
goog.asserts.assert(lon <= this.maxLon_,
'lon should be smaller than or equal to this.maxLon_');
var flatCoordinates = ol.geom.flat.geodesic.meridian(lon,
this.minLat_, this.maxLat_, this.projection_, squaredTolerance);
goog.asserts.assert(flatCoordinates.length > 0);
goog.asserts.assert(flatCoordinates.length > 0,
'flatCoordinates cannot be empty');
var lineString = goog.isDef(this.meridians_[index]) ?
this.meridians_[index] : new ol.geom.LineString(null);
lineString.setFlatCoordinates(ol.geom.GeometryLayout.XY, flatCoordinates);
@@ -316,11 +320,14 @@ ol.Graticule.prototype.getMeridians = function() {
* @private
*/
ol.Graticule.prototype.getParallel_ = function(lat, squaredTolerance, index) {
goog.asserts.assert(lat >= this.minLat_);
goog.asserts.assert(lat <= this.maxLat_);
goog.asserts.assert(lat >= this.minLat_,
'lat should be larger than or equal to this.minLat_');
goog.asserts.assert(lat <= this.maxLat_,
'lat should be smaller than or equal to this.maxLat_');
var flatCoordinates = ol.geom.flat.geodesic.parallel(lat,
this.minLon_, this.maxLon_, this.projection_, squaredTolerance);
goog.asserts.assert(flatCoordinates.length > 0);
goog.asserts.assert(flatCoordinates.length > 0,
'flatCoordinates cannot be empty');
var lineString = goog.isDef(this.parallels_[index]) ?
this.parallels_[index] : new ol.geom.LineString(null);
lineString.setFlatCoordinates(ol.geom.GeometryLayout.XY, flatCoordinates);
@@ -381,7 +388,7 @@ ol.Graticule.prototype.handlePostCompose_ = function(e) {
* @private
*/
ol.Graticule.prototype.updateProjectionInfo_ = function(projection) {
goog.asserts.assert(!goog.isNull(projection));
goog.asserts.assert(!goog.isNull(projection), 'projection cannot be null');
var extent = projection.getExtent();
var worldExtent = projection.getWorldExtent();
@@ -390,11 +397,11 @@ ol.Graticule.prototype.updateProjectionInfo_ = function(projection) {
var minLat = worldExtent[1];
var minLon = worldExtent[0];
goog.asserts.assert(!goog.isNull(extent));
goog.asserts.assert(goog.isDef(maxLat));
goog.asserts.assert(goog.isDef(maxLon));
goog.asserts.assert(goog.isDef(minLat));
goog.asserts.assert(goog.isDef(minLon));
goog.asserts.assert(!goog.isNull(extent), 'extent cannot be null');
goog.asserts.assert(goog.isDef(maxLat), 'maxLat should be defined');
goog.asserts.assert(goog.isDef(maxLon), 'maxLon should be defined');
goog.asserts.assert(goog.isDef(minLat), 'minLat should be defined');
goog.asserts.assert(goog.isDef(minLon), 'minLon should be defined');
this.maxLat_ = maxLat;
this.maxLon_ = maxLon;

6
src/ol/image.js
View File

@@ -129,7 +129,8 @@ ol.Image.prototype.load = function() {
if (this.state == ol.ImageState.IDLE) {
this.state = ol.ImageState.LOADING;
this.changed();
goog.asserts.assert(goog.isNull(this.imageListenerKeys_));
goog.asserts.assert(goog.isNull(this.imageListenerKeys_),
'this.imageListenerKeys_ should be null');
this.imageListenerKeys_ = [
goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
this.handleImageError_, false, this),
@@ -147,7 +148,8 @@ ol.Image.prototype.load = function() {
* @private
*/
ol.Image.prototype.unlistenImage_ = function() {
goog.asserts.assert(!goog.isNull(this.imageListenerKeys_));
goog.asserts.assert(!goog.isNull(this.imageListenerKeys_),
'this.imageListenerKeys_ should not be null');
goog.array.forEach(this.imageListenerKeys_, goog.events.unlistenByKey);
this.imageListenerKeys_ = null;
};

6
src/ol/imagetile.js
View File

@@ -148,7 +148,8 @@ ol.ImageTile.prototype.load = function() {
if (this.state == ol.TileState.IDLE) {
this.state = ol.TileState.LOADING;
this.changed();
goog.asserts.assert(goog.isNull(this.imageListenerKeys_));
goog.asserts.assert(goog.isNull(this.imageListenerKeys_),
'this.imageListenerKeys_ should be null');
this.imageListenerKeys_ = [
goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
this.handleImageError_, false, this),
@@ -166,7 +167,8 @@ ol.ImageTile.prototype.load = function() {
* @private
*/
ol.ImageTile.prototype.unlistenImage_ = function() {
goog.asserts.assert(!goog.isNull(this.imageListenerKeys_));
goog.asserts.assert(!goog.isNull(this.imageListenerKeys_),
'this.imageListenerKeys_ should not be null');
goog.array.forEach(this.imageListenerKeys_, goog.events.unlistenByKey);
this.imageListenerKeys_ = null;
};

2
src/ol/interaction/doubleclickzoominteraction.js
View File

@@ -54,7 +54,7 @@ ol.interaction.DoubleClickZoom.handleEvent = function(mapBrowserEvent) {
var anchor = mapBrowserEvent.coordinate;
var delta = browserEvent.shiftKey ? -this.delta_ : this.delta_;
var view = map.getView();
goog.asserts.assert(!goog.isNull(view));
goog.asserts.assert(!goog.isNull(view), 'view should not be null');
ol.interaction.Interaction.zoomByDelta(
map, view, delta, anchor, this.duration_);
mapBrowserEvent.preventDefault();

10
src/ol/interaction/draganddropinteraction.js
View File

@@ -98,13 +98,14 @@ ol.interaction.DragAndDrop.prototype.handleDrop_ = function(event) {
*/
ol.interaction.DragAndDrop.prototype.handleResult_ = function(file, result) {
var map = this.getMap();
goog.asserts.assert(!goog.isNull(map));
goog.asserts.assert(!goog.isNull(map), 'map should not be null');
var projection = this.projection_;
if (goog.isNull(projection)) {
var view = map.getView();
goog.asserts.assert(!goog.isNull(view));
goog.asserts.assert(!goog.isNull(view), 'view should not be null');
projection = view.getProjection();
goog.asserts.assert(goog.isDef(projection));
goog.asserts.assert(goog.isDef(projection),
'projection should be defined');
}
var formatConstructors = this.formatConstructors_;
var features = [];
@@ -155,7 +156,8 @@ ol.interaction.DragAndDrop.prototype.setMap = function(map) {
goog.dispose(this.fileDropHandler_);
this.fileDropHandler_ = null;
}
goog.asserts.assert(!goog.isDef(this.dropListenKey_));
goog.asserts.assert(!goog.isDef(this.dropListenKey_),
'this.dropListenKey_ should be undefined');
goog.base(this, 'setMap', map);
if (!goog.isNull(map)) {
this.fileDropHandler_ = new goog.events.FileDropHandler(map.getViewport());

5
src/ol/interaction/dragpaninteraction.js
View File

@@ -70,7 +70,8 @@ goog.inherits(ol.interaction.DragPan, ol.interaction.Pointer);
* @private
*/
ol.interaction.DragPan.handleDragEvent_ = function(mapBrowserEvent) {
goog.asserts.assert(this.targetPointers.length >= 1);
goog.asserts.assert(this.targetPointers.length >= 1,
'the length of this.targetPointers should be more than 1');
var centroid =
ol.interaction.Pointer.centroid(this.targetPointers);
if (this.kinetic_) {
@@ -108,7 +109,7 @@ ol.interaction.DragPan.handleUpEvent_ = function(mapBrowserEvent) {
var distance = this.kinetic_.getDistance();
var angle = this.kinetic_.getAngle();
var center = view.getCenter();
goog.asserts.assert(goog.isDef(center));
goog.asserts.assert(goog.isDef(center), 'center should be defined');
this.kineticPreRenderFn_ = this.kinetic_.pan(center);
map.beforeRender(this.kineticPreRenderFn_);
var centerpx = map.getPixelFromCoordinate(center);

4
src/ol/interaction/dragzoominteraction.js
View File

@@ -54,11 +54,11 @@ goog.inherits(ol.interaction.DragZoom, ol.interaction.DragBox);
ol.interaction.DragZoom.prototype.onBoxEnd = function() {
var map = this.getMap();
var view = map.getView();
goog.asserts.assert(!goog.isNull(view));
goog.asserts.assert(!goog.isNull(view), 'view should not be null');
var extent = this.getGeometry().getExtent();
var center = ol.extent.getCenter(extent);
var size = map.getSize();
goog.asserts.assert(goog.isDef(size));
goog.asserts.assert(goog.isDef(size), 'size should be defined');
ol.interaction.Interaction.zoom(map, view,
view.getResolutionForExtent(extent, size),
center, ol.DRAGZOOM_ANIMATION_DURATION);

61
src/ol/interaction/drawinteraction.js
View File

@@ -336,10 +336,12 @@ ol.interaction.Draw.prototype.atFinish_ = function(event) {
var potentiallyDone = false;
var potentiallyFinishCoordinates = [this.finishCoordinate_];
if (this.mode_ === ol.interaction.DrawMode.LINE_STRING) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
potentiallyDone = geometry.getCoordinates().length > 2;
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
potentiallyDone = geometry.getCoordinates()[0].length >
this.minPointsPerRing_;
potentiallyFinishCoordinates = [this.sketchPolygonCoords_[0][0],
@@ -376,7 +378,8 @@ ol.interaction.Draw.prototype.createOrUpdateSketchPoint_ = function(event) {
this.updateSketchFeatures_();
} else {
var sketchPointGeom = this.sketchPoint_.getGeometry();
goog.asserts.assertInstanceof(sketchPointGeom, ol.geom.Point);
goog.asserts.assertInstanceof(sketchPointGeom, ol.geom.Point,
'sketchPointGeom should be an ol.geom.Point');
sketchPointGeom.setCoordinates(coordinates);
}
};
@@ -407,7 +410,7 @@ ol.interaction.Draw.prototype.startDrawing_ = function(event) {
start.slice()]));
}
}
goog.asserts.assert(goog.isDef(geometry));
goog.asserts.assert(goog.isDef(geometry), 'geometry should be defined');
this.sketchFeature_ = new ol.Feature();
if (goog.isDef(this.geometryName_)) {
this.sketchFeature_.setGeometryName(this.geometryName_);
@@ -429,20 +432,24 @@ ol.interaction.Draw.prototype.modifyDrawing_ = function(event) {
var geometry = this.sketchFeature_.getGeometry();
var coordinates, last, sketchLineGeom;
if (this.mode_ === ol.interaction.DrawMode.POINT) {
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
last = geometry.getCoordinates();
last[0] = coordinate[0];
last[1] = coordinate[1];
geometry.setCoordinates(last);
} else {
if (this.mode_ === ol.interaction.DrawMode.LINE_STRING) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
coordinates = geometry.getCoordinates();
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
coordinates = this.sketchPolygonCoords_[0];
} else if (this.mode_ === ol.interaction.DrawMode.CIRCLE) {
goog.asserts.assertInstanceof(geometry, ol.geom.Circle);
goog.asserts.assertInstanceof(geometry, ol.geom.Circle,
'geometry should be an ol.geom.Circle');
coordinates = geometry.getCenter();
}
if (this.atFinish_(event)) {
@@ -450,24 +457,30 @@ ol.interaction.Draw.prototype.modifyDrawing_ = function(event) {
coordinate = this.finishCoordinate_.slice();
}
var sketchPointGeom = this.sketchPoint_.getGeometry();
goog.asserts.assertInstanceof(sketchPointGeom, ol.geom.Point);
goog.asserts.assertInstanceof(sketchPointGeom, ol.geom.Point,
'sketchPointGeom should be an ol.geom.Point');
sketchPointGeom.setCoordinates(coordinate);
last = coordinates[coordinates.length - 1];
last[0] = coordinate[0];
last[1] = coordinate[1];
if (this.mode_ === ol.interaction.DrawMode.LINE_STRING) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
geometry.setCoordinates(coordinates);
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
sketchLineGeom = this.sketchLine_.getGeometry();
goog.asserts.assertInstanceof(sketchLineGeom, ol.geom.LineString);
goog.asserts.assertInstanceof(sketchLineGeom, ol.geom.LineString,
'sketchLineGeom should be an ol.geom.LineString');
sketchLineGeom.setCoordinates(coordinates);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
geometry.setCoordinates(this.sketchPolygonCoords_);
} else if (this.mode_ === ol.interaction.DrawMode.CIRCLE) {
goog.asserts.assertInstanceof(geometry, ol.geom.Circle);
goog.asserts.assertInstanceof(geometry, ol.geom.Circle,
'geometry should be an ol.geom.Circle');
sketchLineGeom = this.sketchLine_.getGeometry();
goog.asserts.assertInstanceof(sketchLineGeom, ol.geom.LineString);
goog.asserts.assertInstanceof(sketchLineGeom, ol.geom.LineString,
'sketchLineGeom should be an ol.geom.LineString');
sketchLineGeom.setCoordinates([geometry.getCenter(), coordinate]);
geometry.setRadius(sketchLineGeom.getLength());
}
@@ -487,13 +500,15 @@ ol.interaction.Draw.prototype.addToDrawing_ = function(event) {
var coordinates;
if (this.mode_ === ol.interaction.DrawMode.LINE_STRING) {
this.finishCoordinate_ = coordinate.slice();
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
coordinates = geometry.getCoordinates();
coordinates.push(coordinate.slice());
geometry.setCoordinates(coordinates);
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
this.sketchPolygonCoords_[0].push(coordinate.slice());
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
geometry.setCoordinates(this.sketchPolygonCoords_);
}
this.updateSketchFeatures_();
@@ -506,20 +521,24 @@ ol.interaction.Draw.prototype.addToDrawing_ = function(event) {
*/
ol.interaction.Draw.prototype.finishDrawing = function() {
var sketchFeature = this.abortDrawing_();
goog.asserts.assert(!goog.isNull(sketchFeature));
goog.asserts.assert(!goog.isNull(sketchFeature),
'sketchFeature should not be null');
var coordinates;
var geometry = sketchFeature.getGeometry();
if (this.mode_ === ol.interaction.DrawMode.POINT) {
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
coordinates = geometry.getCoordinates();
} else if (this.mode_ === ol.interaction.DrawMode.LINE_STRING) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
coordinates = geometry.getCoordinates();
// remove the redundant last point
coordinates.pop();
geometry.setCoordinates(coordinates);
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
// When we finish drawing a polygon on the last point,
// the last coordinate is duplicated as for LineString
// we force the replacement by the first point
@@ -625,7 +644,7 @@ ol.interaction.Draw.getMode_ = function(type) {
} else if (type === ol.geom.GeometryType.CIRCLE) {
mode = ol.interaction.DrawMode.CIRCLE;
}
goog.asserts.assert(goog.isDef(mode));
goog.asserts.assert(goog.isDef(mode), 'mode should be defined');
return mode;
};

2
src/ol/interaction/keyboardpaninteraction.js
View File

@@ -74,7 +74,7 @@ ol.interaction.KeyboardPan.handleEvent = function(mapBrowserEvent) {
keyCode == goog.events.KeyCodes.UP)) {
var map = mapBrowserEvent.map;
var view = map.getView();
goog.asserts.assert(!goog.isNull(view));
goog.asserts.assert(!goog.isNull(view), 'view should not be null');
var viewState = view.getState();
var mapUnitsDelta = viewState.resolution * this.pixelDelta_;
var deltaX = 0, deltaY = 0;

2
src/ol/interaction/keyboardzoominteraction.js
View File

@@ -74,7 +74,7 @@ ol.interaction.KeyboardZoom.handleEvent = function(mapBrowserEvent) {
var delta = (charCode == '+'.charCodeAt(0)) ? this.delta_ : -this.delta_;
map.render();
var view = map.getView();
goog.asserts.assert(!goog.isNull(view));
goog.asserts.assert(!goog.isNull(view), 'view should not be null');
ol.interaction.Interaction.zoomByDelta(
map, view, delta, undefined, this.duration_);
mapBrowserEvent.preventDefault();

24
src/ol/interaction/modifyinteraction.js
View File

@@ -183,7 +183,8 @@ ol.interaction.Modify.prototype.setMap = function(map) {
*/
ol.interaction.Modify.prototype.handleFeatureAdd_ = function(evt) {
var feature = evt.element;
goog.asserts.assertInstanceof(feature, ol.Feature);
goog.asserts.assertInstanceof(feature, ol.Feature,
'feature should be an ol.Feature');
this.addFeature_(feature);
};
@@ -549,7 +550,8 @@ ol.interaction.Modify.handleEvent = function(mapBrowserEvent) {
if (!goog.isNull(this.vertexFeature_) &&
this.deleteCondition_(mapBrowserEvent)) {
var geometry = this.vertexFeature_.getGeometry();
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
handled = this.removeVertex_();
}
return ol.interaction.Pointer.handleEvent.call(this, mapBrowserEvent) &&
@@ -651,22 +653,26 @@ ol.interaction.Modify.prototype.insertVertex_ = function(segmentData, vertex) {
switch (geometry.getType()) {
case ol.geom.GeometryType.MULTI_LINE_STRING:
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString,
'geometry should be an ol.geom.MultiLineString');
coordinates = geometry.getCoordinates();
coordinates[depth[0]].splice(index + 1, 0, vertex);
break;
case ol.geom.GeometryType.POLYGON:
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
coordinates = geometry.getCoordinates();
coordinates[depth[0]].splice(index + 1, 0, vertex);
break;
case ol.geom.GeometryType.MULTI_POLYGON:
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPolygon);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPolygon,
'geometry should be an ol.geom.MultiPolygon');
coordinates = geometry.getCoordinates();
coordinates[depth[1]][depth[0]].splice(index + 1, 0, vertex);
break;
case ol.geom.GeometryType.LINE_STRING:
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
coordinates = geometry.getCoordinates();
coordinates.splice(index + 1, 0, vertex);
break;
@@ -676,9 +682,9 @@ ol.interaction.Modify.prototype.insertVertex_ = function(segmentData, vertex) {
geometry.setCoordinates(coordinates);
var rTree = this.rBush_;
goog.asserts.assert(goog.isDef(segment));
goog.asserts.assert(goog.isDef(segment), 'segment should be defined');
rTree.remove(segmentData);
goog.asserts.assert(goog.isDef(index));
goog.asserts.assert(goog.isDef(index), 'index should be defined');
this.updateSegmentIndices_(geometry, index, depth, 1);
var newSegmentData = /** @type {ol.interaction.SegmentDataType} */ ({
segment: [segment[0], vertex],
@@ -780,7 +786,7 @@ ol.interaction.Modify.prototype.removeVertex_ = function() {
this.rBush_.remove(newSegment[0]);
this.rBush_.remove(newSegment[1]);
geometry.setCoordinates(coordinates);
goog.asserts.assert(newIndex >= 0);
goog.asserts.assert(newIndex >= 0, 'newIndex should be larger than 0');
var newSegmentData = /** @type {ol.interaction.SegmentDataType} */ ({
depth: segmentData.depth,
feature: segmentData.feature,

5
src/ol/interaction/mousewheelzoominteraction.js
View File

@@ -73,7 +73,8 @@ ol.interaction.MouseWheelZoom.handleEvent = function(mapBrowserEvent) {
goog.events.MouseWheelHandler.EventType.MOUSEWHEEL) {
var map = mapBrowserEvent.map;
var mouseWheelEvent = mapBrowserEvent.browserEvent;
goog.asserts.assertInstanceof(mouseWheelEvent, goog.events.MouseWheelEvent);
goog.asserts.assertInstanceof(mouseWheelEvent, goog.events.MouseWheelEvent,
'mouseWheelEvent should be of type MouseWheelEvent');
this.lastAnchor_ = mapBrowserEvent.coordinate;
this.delta_ += mouseWheelEvent.deltaY;
@@ -105,7 +106,7 @@ ol.interaction.MouseWheelZoom.prototype.doZoom_ = function(map) {
var delta = goog.math.clamp(this.delta_, -maxDelta, maxDelta);
var view = map.getView();
goog.asserts.assert(!goog.isNull(view));
goog.asserts.assert(!goog.isNull(view), 'view should not be null');
map.render();
ol.interaction.Interaction.zoomByDelta(map, view, -delta, this.lastAnchor_,

3
src/ol/interaction/pinchrotateinteraction.js
View File

@@ -71,7 +71,8 @@ goog.inherits(ol.interaction.PinchRotate, ol.interaction.Pointer);
* @private
*/
ol.interaction.PinchRotate.handleDragEvent_ = function(mapBrowserEvent) {
goog.asserts.assert(this.targetPointers.length >= 2);
goog.asserts.assert(this.targetPointers.length >= 2,
'length of this.targetPointers should be greater than or equal to 2');
var rotationDelta = 0.0;
var touch0 = this.targetPointers[0];

3
src/ol/interaction/pinchzoominteraction.js
View File

@@ -64,7 +64,8 @@ goog.inherits(ol.interaction.PinchZoom, ol.interaction.Pointer);
* @private
*/
ol.interaction.PinchZoom.handleDragEvent_ = function(mapBrowserEvent) {
goog.asserts.assert(this.targetPointers.length >= 2);
goog.asserts.assert(this.targetPointers.length >= 2,
'length of this.targetPointers should be 2 or more');
var scaleDelta = 1.0;
var touch0 = this.targetPointers[0];

6
src/ol/interaction/selectinteraction.js
View File

@@ -311,7 +311,8 @@ ol.interaction.Select.getDefaultStyleFunction = function() {
ol.interaction.Select.prototype.addFeature_ = function(evt) {
var feature = evt.element;
var map = this.getMap();
goog.asserts.assertInstanceof(feature, ol.Feature);
goog.asserts.assertInstanceof(feature, ol.Feature,
'feature should be an ol.Feature');
if (!goog.isNull(map)) {
map.skipFeature(feature);
}
@@ -325,7 +326,8 @@ ol.interaction.Select.prototype.addFeature_ = function(evt) {
ol.interaction.Select.prototype.removeFeature_ = function(evt) {
var feature = evt.element;
var map = this.getMap();
goog.asserts.assertInstanceof(feature, ol.Feature);
goog.asserts.assertInstanceof(feature, ol.Feature,
'feature should be an ol.Feature');
if (!goog.isNull(map)) {
map.unskipFeature(feature);
}

9
src/ol/interaction/snapinteraction.js
View File

@@ -213,7 +213,7 @@ ol.interaction.Snap.prototype.getFeatures_ = function() {
} else if (!goog.isNull(this.source_)) {
features = this.source_.getFeatures();
}
goog.asserts.assert(goog.isDef(features));
goog.asserts.assert(goog.isDef(features), 'features should be defined');
return features;
};
@@ -229,7 +229,8 @@ ol.interaction.Snap.prototype.handleFeatureAdd_ = function(evt) {
} else if (evt instanceof ol.CollectionEvent) {
feature = evt.element;
}
goog.asserts.assertInstanceof(feature, ol.Feature);
goog.asserts.assertInstanceof(feature, ol.Feature,
'feature should be an ol.Feature');
this.addFeature(feature);
};
@@ -245,7 +246,8 @@ ol.interaction.Snap.prototype.handleFeatureRemove_ = function(evt) {
} else if (evt instanceof ol.CollectionEvent) {
feature = evt.element;
}
goog.asserts.assertInstanceof(feature, ol.Feature);
goog.asserts.assertInstanceof(feature, ol.Feature,
'feature should be an ol.Feature');
this.removeFeature(feature);
};
@@ -300,7 +302,6 @@ ol.interaction.Snap.prototype.removeFeature = function(feature, opt_unlisten) {
for (i = nodesToRemove.length - 1; i >= 0; --i) {
rBush.remove(nodesToRemove[i]);
}
if (unlisten) {
ol.Observable.unByKey(this.geometryModifyListenerKeys_[feature_uid]);
delete this.geometryModifyListenerKeys_[feature_uid];

18
src/ol/layer/heatmaplayer.js
View File

@@ -99,11 +99,14 @@ ol.layer.Heatmap = function(opt_options) {
} else {
weightFunction = weight;
}
goog.asserts.assert(goog.isFunction(weightFunction));
goog.asserts.assert(goog.isFunction(weightFunction),
'weightFunction should be a function');
this.setStyle(goog.bind(function(feature, resolution) {
goog.asserts.assert(!goog.isNull(this.styleCache_));
goog.asserts.assert(goog.isDef(this.circleImage_));
goog.asserts.assert(!goog.isNull(this.styleCache_),
'this.styleCache_ should not be null');
goog.asserts.assert(goog.isDef(this.circleImage_),
'this.circleImage_ should be defined');
var weight = weightFunction(feature);
var opacity = goog.isDef(weight) ? goog.math.clamp(weight, 0, 1) : 1;
// cast to 8 bits
@@ -171,7 +174,8 @@ ol.layer.Heatmap.createGradient_ = function(colors) {
ol.layer.Heatmap.prototype.createCircle_ = function() {
var radius = this.getRadius();
var blur = this.getBlur();
goog.asserts.assert(goog.isDef(radius) && goog.isDef(blur));
goog.asserts.assert(goog.isDef(radius) && goog.isDef(blur),
'radius and blur should be defined');
var halfSize = radius + blur + 1;
var size = 2 * halfSize;
var context = ol.dom.createCanvasContext2D(size, size);
@@ -252,8 +256,10 @@ ol.layer.Heatmap.prototype.handleStyleChanged_ = function() {
* @private
*/
ol.layer.Heatmap.prototype.handleRender_ = function(event) {
goog.asserts.assert(event.type == ol.render.EventType.RENDER);
goog.asserts.assert(!goog.isNull(this.gradient_));
goog.asserts.assert(event.type == ol.render.EventType.RENDER,
'event.type should be RENDER');
goog.asserts.assert(!goog.isNull(this.gradient_),
'this.gradient_ should not be null');
var context = event.context;
var canvas = context.canvas;
var image = context.getImageData(0, 0, canvas.width, canvas.height);

3
src/ol/layer/layergroup.js
View File

@@ -60,7 +60,8 @@ ol.layer.Group = function(opt_options) {
if (goog.isArray(layers)) {
layers = new ol.Collection(layers.slice());
} else {
goog.asserts.assertInstanceof(layers, ol.Collection);
goog.asserts.assertInstanceof(layers, ol.Collection,
'layers should be an ol.Collection');
layers = layers;
}
} else {

36
src/ol/map.js
View File

@@ -479,7 +479,7 @@ goog.inherits(ol.Map, ol.Object);
*/
ol.Map.prototype.addControl = function(control) {
var controls = this.getControls();
goog.asserts.assert(goog.isDef(controls));
goog.asserts.assert(goog.isDef(controls), 'controls should be defined');
controls.push(control);
};
@@ -491,7 +491,8 @@ ol.Map.prototype.addControl = function(control) {
*/
ol.Map.prototype.addInteraction = function(interaction) {
var interactions = this.getInteractions();
goog.asserts.assert(goog.isDef(interactions));
goog.asserts.assert(goog.isDef(interactions),
'interactions should be defined');
interactions.push(interaction);
};
@@ -514,7 +515,7 @@ ol.Map.prototype.addLayer = function(layer) {
*/
ol.Map.prototype.addOverlay = function(overlay) {
var overlays = this.getOverlays();
goog.asserts.assert(goog.isDef(overlays));
goog.asserts.assert(goog.isDef(overlays), 'overlays should be defined');
overlays.push(overlay);
};
@@ -939,7 +940,8 @@ ol.Map.prototype.handleMapBrowserEvent = function(mapBrowserEvent) {
this.focus_ = mapBrowserEvent.coordinate;
mapBrowserEvent.frameState = this.frameState_;
var interactions = this.getInteractions();
goog.asserts.assert(goog.isDef(interactions));
goog.asserts.assert(goog.isDef(interactions),
'interactions should be defined');
var interactionsArray = interactions.getArray();
var i;
if (this.dispatchEvent(mapBrowserEvent) !== false) {
@@ -1083,7 +1085,8 @@ ol.Map.prototype.handleViewChanged_ = function() {
* @private
*/
ol.Map.prototype.handleLayerGroupMemberChanged_ = function(event) {
goog.asserts.assertInstanceof(event, goog.events.Event);
goog.asserts.assertInstanceof(event, goog.events.Event,
'event should be an Event');
this.render();
};
@@ -1093,7 +1096,8 @@ ol.Map.prototype.handleLayerGroupMemberChanged_ = function(event) {
* @private
*/
ol.Map.prototype.handleLayerGroupPropertyChanged_ = function(event) {
goog.asserts.assertInstanceof(event, ol.ObjectEvent);
goog.asserts.assertInstanceof(event, ol.ObjectEvent,
'event should be an ol.ObjectEvent');
this.render();
};
@@ -1187,7 +1191,7 @@ ol.Map.prototype.render = function() {
*/
ol.Map.prototype.removeControl = function(control) {
var controls = this.getControls();
goog.asserts.assert(goog.isDef(controls));
goog.asserts.assert(goog.isDef(controls), 'controls should be defined');
if (goog.isDef(controls.remove(control))) {
return control;
}
@@ -1205,7 +1209,8 @@ ol.Map.prototype.removeControl = function(control) {
ol.Map.prototype.removeInteraction = function(interaction) {
var removed;
var interactions = this.getInteractions();
goog.asserts.assert(goog.isDef(interactions));
goog.asserts.assert(goog.isDef(interactions),
'interactions should be defined');
if (goog.isDef(interactions.remove(interaction))) {
removed = interaction;
}
@@ -1235,7 +1240,7 @@ ol.Map.prototype.removeLayer = function(layer) {
*/
ol.Map.prototype.removeOverlay = function(overlay) {
var overlays = this.getOverlays();
goog.asserts.assert(goog.isDef(overlays));
goog.asserts.assert(goog.isDef(overlays), 'overlays should be defined');
if (goog.isDef(overlays.remove(overlay))) {
return overlay;
}
@@ -1491,8 +1496,8 @@ ol.Map.createOptionsInternal = function(options) {
if (goog.isString(logo)) {
logos[logo] = '';
} else if (goog.isObject(logo)) {
goog.asserts.assertString(logo.href);
goog.asserts.assertString(logo.src);
goog.asserts.assertString(logo.href, 'logo.href should be a string');
goog.asserts.assertString(logo.src, 'logo.src should be a string');
logos[logo.src] = logo.href;
}
}
@@ -1554,7 +1559,8 @@ ol.Map.createOptionsInternal = function(options) {
if (goog.isArray(options.controls)) {
controls = new ol.Collection(options.controls.slice());
} else {
goog.asserts.assertInstanceof(options.controls, ol.Collection);
goog.asserts.assertInstanceof(options.controls, ol.Collection,
'options.controls should be an ol.Collection');
controls = options.controls;
}
} else {
@@ -1566,7 +1572,8 @@ ol.Map.createOptionsInternal = function(options) {
if (goog.isArray(options.interactions)) {
interactions = new ol.Collection(options.interactions.slice());
} else {
goog.asserts.assertInstanceof(options.interactions, ol.Collection);
goog.asserts.assertInstanceof(options.interactions, ol.Collection,
'options.interactions should be an ol.Collection');
interactions = options.interactions;
}
} else {
@@ -1578,7 +1585,8 @@ ol.Map.createOptionsInternal = function(options) {
if (goog.isArray(options.overlays)) {
overlays = new ol.Collection(options.overlays.slice());
} else {
goog.asserts.assertInstanceof(options.overlays, ol.Collection);
goog.asserts.assertInstanceof(options.overlays, ol.Collection,
'options.overlays should be an ol.Collection');
overlays = options.overlays;
}
} else {

6
src/ol/mapbrowserevent.js
View File

@@ -315,11 +315,13 @@ ol.MapBrowserEventHandler.prototype.handlePointerUp_ = function(pointerEvent) {
// to 0).
// See http://www.w3.org/TR/pointerevents/#button-states
if (!this.dragging_ && this.isMouseActionButton_(pointerEvent)) {
goog.asserts.assert(!goog.isNull(this.down_));
goog.asserts.assert(!goog.isNull(this.down_),
'this.down_ should not be null');
this.emulateClick_(this.down_);
}
goog.asserts.assert(this.activePointers_ >= 0);
goog.asserts.assert(this.activePointers_ >= 0,
'this.activePointers_ should be equal to or larger than 0');
if (this.activePointers_ === 0) {
goog.array.forEach(this.dragListenerKeys_, goog.events.unlistenByKey);
this.dragListenerKeys_ = null;

2
src/ol/math.js
View File

@@ -36,7 +36,7 @@ ol.math.csch = function(x) {
* @return {number} The smallest power of two greater than or equal to x.
*/
ol.math.roundUpToPowerOfTwo = function(x) {
goog.asserts.assert(0 < x);
goog.asserts.assert(0 < x, 'x should be larger than 0');
return Math.pow(2, Math.ceil(Math.log(x) / Math.LN2));
};

21
src/ol/overlay.js
View File

@@ -398,7 +398,7 @@ goog.exportProperty(
* @private
*/
ol.Overlay.prototype.panIntoView_ = function() {
goog.asserts.assert(this.autoPan_);
goog.asserts.assert(this.autoPan_, 'this.autoPan_ should be true');
var map = this.getMap();
if (!goog.isDef(map) || goog.isNull(map.getTargetElement())) {
@@ -407,7 +407,8 @@ ol.Overlay.prototype.panIntoView_ = function() {
var mapRect = this.getRect_(map.getTargetElement(), map.getSize());
var element = this.getElement();
goog.asserts.assert(!goog.isNull(element) && goog.isDef(element));
goog.asserts.assert(goog.isDefAndNotNull(element),
'element should be defined');
var overlayRect = this.getRect_(element,
[ol.dom.outerWidth(element), ol.dom.outerHeight(element)]);
@@ -437,7 +438,7 @@ ol.Overlay.prototype.panIntoView_ = function() {
if (delta[0] !== 0 || delta[1] !== 0) {
var center = map.getView().getCenter();
goog.asserts.assert(goog.isDef(center));
goog.asserts.assert(goog.isDef(center), 'center should be defined');
var centerPx = map.getPixelFromCoordinate(center);
var newCenterPx = [
centerPx[0] + delta[0],
@@ -462,8 +463,9 @@ ol.Overlay.prototype.panIntoView_ = function() {
* @private
*/
ol.Overlay.prototype.getRect_ = function(element, size) {
goog.asserts.assert(!goog.isNull(element) && goog.isDef(element));
goog.asserts.assert(goog.isDef(size));
goog.asserts.assert(goog.isDefAndNotNull(element),
'element should be defined');
goog.asserts.assert(goog.isDef(size), 'size should be defined');
var offset = goog.style.getPageOffset(element);
return [
@@ -507,14 +509,15 @@ ol.Overlay.prototype.updatePixelPosition_ = function() {
}
var pixel = map.getPixelFromCoordinate(position);
goog.asserts.assert(!goog.isNull(pixel));
goog.asserts.assert(!goog.isNull(pixel), 'pixel should not be null');
var mapSize = map.getSize();
goog.asserts.assert(goog.isDef(mapSize));
goog.asserts.assert(goog.isDef(mapSize), 'mapSize should be defined');
var style = this.element_.style;
var offset = this.getOffset();
goog.asserts.assert(goog.isArray(offset));
goog.asserts.assert(goog.isArray(offset), 'offset should be an array');
var positioning = this.getPositioning();
goog.asserts.assert(goog.isDef(positioning));
goog.asserts.assert(goog.isDef(positioning),
'positioning should be defined');
var offsetX = offset[0];
var offsetY = offset[1];

6
src/ol/proj/epsg3857projection.js
View File

@@ -118,7 +118,8 @@ ol.proj.EPSG3857.fromEPSG4326 = function(input, opt_output, opt_dimension) {
output = new Array(length);
}
}
goog.asserts.assert(output.length % dimension === 0);
goog.asserts.assert(output.length % dimension === 0,
'modulus of output.length with dimension should be 0');
for (var i = 0; i < length; i += dimension) {
output[i] = ol.proj.EPSG3857.RADIUS * Math.PI * input[i] / 180;
output[i + 1] = ol.proj.EPSG3857.RADIUS *
@@ -148,7 +149,8 @@ ol.proj.EPSG3857.toEPSG4326 = function(input, opt_output, opt_dimension) {
output = new Array(length);
}
}
goog.asserts.assert(output.length % dimension === 0);
goog.asserts.assert(output.length % dimension === 0,
'modulus of output.length with dimension should be 0');
for (var i = 0; i < length; i += dimension) {
output[i] = 180 * input[i] / (ol.proj.EPSG3857.RADIUS * Math.PI);
output[i + 1] = 360 * Math.atan(

11
src/ol/proj/proj.js
View File

@@ -470,7 +470,8 @@ ol.proj.createProjection = function(projection, defaultCode) {
} else if (goog.isString(projection)) {
return ol.proj.get(projection);
} else {
goog.asserts.assertInstanceof(projection, ol.proj.Projection);
goog.asserts.assertInstanceof(projection, ol.proj.Projection,
'projection should be an ol.proj.Projection');
return projection;
}
};
@@ -571,8 +572,10 @@ ol.proj.removeTransform = function(source, destination) {
var sourceCode = source.getCode();
var destinationCode = destination.getCode();
var transforms = ol.proj.transforms_;
goog.asserts.assert(sourceCode in transforms);
goog.asserts.assert(destinationCode in transforms[sourceCode]);
goog.asserts.assert(sourceCode in transforms,
'sourceCode should be in transforms');
goog.asserts.assert(destinationCode in transforms[sourceCode],
'destinationCode should be in transforms of sourceCode');
var transform = transforms[sourceCode][destinationCode];
delete transforms[sourceCode][destinationCode];
var keys = goog.object.getKeys(transforms[sourceCode]);
@@ -671,7 +674,7 @@ ol.proj.getTransformFromProjections =
transform = transforms[sourceCode][destinationCode];
}
if (!goog.isDef(transform)) {
goog.asserts.assert(goog.isDef(transform));
goog.asserts.assert(goog.isDef(transform), 'transform should be defined');
transform = ol.proj.identityTransform;
}
return transform;

13
src/ol/render/box.js
View File

@@ -63,9 +63,11 @@ goog.inherits(ol.render.Box, goog.Disposable);
* @return {ol.geom.Polygon} Geometry.
*/
ol.render.Box.prototype.createGeometry_ = function() {
goog.asserts.assert(!goog.isNull(this.startPixel_));
goog.asserts.assert(!goog.isNull(this.endPixel_));
goog.asserts.assert(!goog.isNull(this.map_));
goog.asserts.assert(!goog.isNull(this.startPixel_),
'this.startPixel_ should not be null');
goog.asserts.assert(!goog.isNull(this.endPixel_),
'this.endPixel_ should not be null');
goog.asserts.assert(!goog.isNull(this.map_), 'this.map_ should not be null');
var startPixel = this.startPixel_;
var endPixel = this.endPixel_;
var pixels = [
@@ -96,9 +98,10 @@ ol.render.Box.prototype.disposeInternal = function() {
*/
ol.render.Box.prototype.handleMapPostCompose_ = function(event) {
var geometry = this.geometry_;
goog.asserts.assert(goog.isDefAndNotNull(geometry));
goog.asserts.assert(goog.isDefAndNotNull(geometry),
'geometry should be defined');
var style = this.style_;
goog.asserts.assert(!goog.isNull(style));
goog.asserts.assert(!goog.isNull(style), 'style should not be null');
// use drawAsync(Infinity) to draw above everything
event.vectorContext.drawAsync(Infinity, function(render) {
render.setFillStrokeStyle(style.getFill(), style.getStroke());

28
src/ol/render/canvas/canvasimmediate.js
View File

@@ -253,8 +253,9 @@ ol.render.canvas.Immediate.prototype.drawImages_ =
if (goog.isNull(this.image_)) {
return;
}
goog.asserts.assert(offset === 0);
goog.asserts.assert(end == flatCoordinates.length);
goog.asserts.assert(offset === 0, 'offset should be 0');
goog.asserts.assert(end == flatCoordinates.length,
'end should be equal to the length of flatCoordinates');
var pixelCoordinates = ol.geom.flat.transform.transform2D(
flatCoordinates, offset, end, 2, this.transform_,
this.pixelCoordinates_);
@@ -322,8 +323,9 @@ ol.render.canvas.Immediate.prototype.drawText_ =
this.setContextStrokeState_(this.textStrokeState_);
}
this.setContextTextState_(this.textState_);
goog.asserts.assert(offset === 0);
goog.asserts.assert(end == flatCoordinates.length);
goog.asserts.assert(offset === 0, 'offset should be 0');
goog.asserts.assert(end == flatCoordinates.length,
'end should be equal to the length of flatCoordinates');
var pixelCoordinates = ol.geom.flat.transform.transform2D(
flatCoordinates, offset, end, stride, this.transform_,
this.pixelCoordinates_);
@@ -492,7 +494,8 @@ ol.render.canvas.Immediate.prototype.drawFeature = function(feature, style) {
render.setTextStyle(style.getText());
var renderGeometry =
ol.render.canvas.Immediate.GEOMETRY_RENDERERS_[geometry.getType()];
goog.asserts.assert(goog.isDef(renderGeometry));
goog.asserts.assert(goog.isDef(renderGeometry),
'renderGeometry should be defined');
renderGeometry.call(render, geometry, null);
});
};
@@ -514,7 +517,8 @@ ol.render.canvas.Immediate.prototype.drawGeometryCollectionGeometry =
var geometry = geometries[i];
var geometryRenderer =
ol.render.canvas.Immediate.GEOMETRY_RENDERERS_[geometry.getType()];
goog.asserts.assert(goog.isDef(geometryRenderer));
goog.asserts.assert(goog.isDef(geometryRenderer),
'geometryRenderer should be defined');
geometryRenderer.call(this, geometry, feature);
}
};
@@ -901,10 +905,14 @@ ol.render.canvas.Immediate.prototype.setImageStyle = function(imageStyle) {
var imageImage = imageStyle.getImage(1);
var imageOrigin = imageStyle.getOrigin();
var imageSize = imageStyle.getSize();
goog.asserts.assert(!goog.isNull(imageAnchor));
goog.asserts.assert(!goog.isNull(imageImage));
goog.asserts.assert(!goog.isNull(imageOrigin));
goog.asserts.assert(!goog.isNull(imageSize));
goog.asserts.assert(!goog.isNull(imageAnchor),
'imageAnchor should not be null');
goog.asserts.assert(!goog.isNull(imageImage),
'imageImage should not be null');
goog.asserts.assert(!goog.isNull(imageOrigin),
'imageOrigin should not be null');
goog.asserts.assert(!goog.isNull(imageSize),
'imageSize should not be null');
this.imageAnchorX_ = imageAnchor[0];
this.imageAnchorY_ = imageAnchor[1];
this.imageHeight_ = imageSize[1];

235
src/ol/render/canvas/canvasreplay.js
View File

@@ -235,7 +235,8 @@ ol.render.canvas.Replay.prototype.replay_ = function(
this.coordinates, 0, this.coordinates.length, 2,
transform, this.pixelCoordinates_);
goog.vec.Mat4.setFromArray(this.renderedTransform_, transform);
goog.asserts.assert(pixelCoordinates === this.pixelCoordinates_);
goog.asserts.assert(pixelCoordinates === this.pixelCoordinates_,
'pixelCoordinates should be the same as this.pixelCoordinates_');
}
var i = 0; // instruction index
var ii = instructions.length; // end of instructions
@@ -264,7 +265,8 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
case ol.render.canvas.Instruction.CIRCLE:
goog.asserts.assert(goog.isNumber(instruction[1]));
goog.asserts.assert(goog.isNumber(instruction[1]),
'second instruction should be a number');
d = /** @type {number} */ (instruction[1]);
var x1 = pixelCoordinates[d];
var y1 = pixelCoordinates[d + 1];
@@ -281,9 +283,11 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
case ol.render.canvas.Instruction.DRAW_IMAGE:
goog.asserts.assert(goog.isNumber(instruction[1]));
goog.asserts.assert(goog.isNumber(instruction[1]),
'second instruction should be a number');
d = /** @type {number} */ (instruction[1]);
goog.asserts.assert(goog.isNumber(instruction[2]));
goog.asserts.assert(goog.isNumber(instruction[2]),
'third instruction should be a number');
dd = /** @type {number} */ (instruction[2]);
var image = /** @type {HTMLCanvasElement|HTMLVideoElement|Image} */
(instruction[3]);
@@ -341,23 +345,32 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
case ol.render.canvas.Instruction.DRAW_TEXT:
goog.asserts.assert(goog.isNumber(instruction[1]));
goog.asserts.assert(goog.isNumber(instruction[1]),
'2nd instruction should be a number');
d = /** @type {number} */ (instruction[1]);
goog.asserts.assert(goog.isNumber(instruction[2]));
goog.asserts.assert(goog.isNumber(instruction[2]),
'3rd instruction should be a number');
dd = /** @type {number} */ (instruction[2]);
goog.asserts.assert(goog.isString(instruction[3]));
goog.asserts.assert(goog.isString(instruction[3]),
'4th instruction should be a number');
text = /** @type {string} */ (instruction[3]);
goog.asserts.assert(goog.isNumber(instruction[4]));
goog.asserts.assert(goog.isNumber(instruction[4]),
'5th instruction should be a number');
var offsetX = /** @type {number} */ (instruction[4]) * pixelRatio;
goog.asserts.assert(goog.isNumber(instruction[5]));
goog.asserts.assert(goog.isNumber(instruction[5]),
'6th instruction should be a number');
var offsetY = /** @type {number} */ (instruction[5]) * pixelRatio;
goog.asserts.assert(goog.isNumber(instruction[6]));
goog.asserts.assert(goog.isNumber(instruction[6]),
'7th instruction should be a number');
rotation = /** @type {number} */ (instruction[6]);
goog.asserts.assert(goog.isNumber(instruction[7]));
goog.asserts.assert(goog.isNumber(instruction[7]),
'8th instruction should be a number');
scale = /** @type {number} */ (instruction[7]) * pixelRatio;
goog.asserts.assert(goog.isBoolean(instruction[8]));
goog.asserts.assert(goog.isBoolean(instruction[8]),
'9th instruction should be a boolean');
fill = /** @type {boolean} */ (instruction[8]);
goog.asserts.assert(goog.isBoolean(instruction[9]));
goog.asserts.assert(goog.isBoolean(instruction[9]),
'10th instruction should be a boolean');
stroke = /** @type {boolean} */ (instruction[9]);
for (; d < dd; d += 2) {
x = pixelCoordinates[d] + offsetX;
@@ -400,9 +413,11 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
case ol.render.canvas.Instruction.MOVE_TO_LINE_TO:
goog.asserts.assert(goog.isNumber(instruction[1]));
goog.asserts.assert(goog.isNumber(instruction[1]),
'2nd instruction should be a number');
d = /** @type {number} */ (instruction[1]);
goog.asserts.assert(goog.isNumber(instruction[2]));
goog.asserts.assert(goog.isNumber(instruction[2]),
'3rd instruction should be a number');
dd = /** @type {number} */ (instruction[2]);
context.moveTo(pixelCoordinates[d], pixelCoordinates[d + 1]);
for (d += 2; d < dd; d += 2) {
@@ -411,17 +426,24 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
case ol.render.canvas.Instruction.SET_FILL_STYLE:
goog.asserts.assert(goog.isString(instruction[1]));
goog.asserts.assert(goog.isString(instruction[1]),
'2nd instruction should be a string');
context.fillStyle = /** @type {string} */ (instruction[1]);
++i;
break;
case ol.render.canvas.Instruction.SET_STROKE_STYLE:
goog.asserts.assert(goog.isString(instruction[1]));
goog.asserts.assert(goog.isNumber(instruction[2]));
goog.asserts.assert(goog.isString(instruction[3]));
goog.asserts.assert(goog.isString(instruction[4]));
goog.asserts.assert(goog.isNumber(instruction[5]));
goog.asserts.assert(!goog.isNull(instruction[6]));
goog.asserts.assert(goog.isString(instruction[1]),
'2nd instruction should be a string');
goog.asserts.assert(goog.isNumber(instruction[2]),
'3rd instruction should be a number');
goog.asserts.assert(goog.isString(instruction[3]),
'4rd instruction should be a string');
goog.asserts.assert(goog.isString(instruction[4]),
'5th instruction should be a string');
goog.asserts.assert(goog.isNumber(instruction[5]),
'6th instruction should be a number');
goog.asserts.assert(!goog.isNull(instruction[6]),
'7th instruction should not be null');
var usePixelRatio = goog.isDef(instruction[7]) ? instruction[7] : true;
var lineWidth = /** @type {number} */ (instruction[2]);
context.strokeStyle = /** @type {string} */ (instruction[1]);
@@ -435,9 +457,12 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
case ol.render.canvas.Instruction.SET_TEXT_STYLE:
goog.asserts.assert(goog.isString(instruction[1]));
goog.asserts.assert(goog.isString(instruction[2]));
goog.asserts.assert(goog.isString(instruction[3]));
goog.asserts.assert(goog.isString(instruction[1]),
'2nd instruction should be a string');
goog.asserts.assert(goog.isString(instruction[2]),
'3rd instruction should be a string');
goog.asserts.assert(goog.isString(instruction[3]),
'4th instruction should be a string');
context.font = /** @type {string} */ (instruction[1]);
context.textAlign = /** @type {string} */ (instruction[2]);
context.textBaseline = /** @type {string} */ (instruction[3]);
@@ -448,13 +473,14 @@ ol.render.canvas.Replay.prototype.replay_ = function(
++i;
break;
default:
goog.asserts.fail();
goog.asserts.fail('Unknown canvas render instruction');
++i; // consume the instruction anyway, to avoid an infinite loop
break;
}
}
// assert that all instructions were consumed
goog.asserts.assert(i == instructions.length);
goog.asserts.assert(i == instructions.length,
'all instructions should be consumed');
return undefined;
};
@@ -512,11 +538,12 @@ ol.render.canvas.Replay.prototype.reverseHitDetectionInstructions_ =
instruction = hitDetectionInstructions[i];
type = /** @type {ol.render.canvas.Instruction} */ (instruction[0]);
if (type == ol.render.canvas.Instruction.END_GEOMETRY) {
goog.asserts.assert(begin == -1);
goog.asserts.assert(begin == -1, 'begin should be -1');
begin = i;
} else if (type == ol.render.canvas.Instruction.BEGIN_GEOMETRY) {
instruction[2] = i;
goog.asserts.assert(begin >= 0);
goog.asserts.assert(begin >= 0,
'begin should be larger than or equal to 0');
ol.array.reverseSubArray(this.hitDetectionInstructions, begin, i);
begin = -1;
}
@@ -598,10 +625,12 @@ ol.render.canvas.Replay.prototype.drawText = goog.abstractMethod;
* @param {ol.Feature} feature Feature.
*/
ol.render.canvas.Replay.prototype.endGeometry = function(geometry, feature) {
goog.asserts.assert(!goog.isNull(this.beginGeometryInstruction1_));
goog.asserts.assert(!goog.isNull(this.beginGeometryInstruction1_),
'this.beginGeometryInstruction1_ should not be null');
this.beginGeometryInstruction1_[2] = this.instructions.length;
this.beginGeometryInstruction1_ = null;
goog.asserts.assert(!goog.isNull(this.beginGeometryInstruction2_));
goog.asserts.assert(!goog.isNull(this.beginGeometryInstruction2_),
'this.beginGeometryInstruction2_ should not be null');
this.beginGeometryInstruction2_[2] = this.hitDetectionInstructions.length;
this.beginGeometryInstruction2_ = null;
var endGeometryInstruction =
@@ -766,16 +795,26 @@ ol.render.canvas.ImageReplay.prototype.drawPointGeometry =
if (goog.isNull(this.image_)) {
return;
}
goog.asserts.assert(goog.isDef(this.anchorX_));
goog.asserts.assert(goog.isDef(this.anchorY_));
goog.asserts.assert(goog.isDef(this.height_));
goog.asserts.assert(goog.isDef(this.opacity_));
goog.asserts.assert(goog.isDef(this.originX_));
goog.asserts.assert(goog.isDef(this.originY_));
goog.asserts.assert(goog.isDef(this.rotateWithView_));
goog.asserts.assert(goog.isDef(this.rotation_));
goog.asserts.assert(goog.isDef(this.scale_));
goog.asserts.assert(goog.isDef(this.width_));
goog.asserts.assert(goog.isDef(this.anchorX_),
'this.anchorX_ should be defined');
goog.asserts.assert(goog.isDef(this.anchorY_),
'this.anchorY_ should be defined');
goog.asserts.assert(goog.isDef(this.height_),
'this.height_ should be defined');
goog.asserts.assert(goog.isDef(this.opacity_),
'this.opacity_ should be defined');
goog.asserts.assert(goog.isDef(this.originX_),
'this.originX_ should be defined');
goog.asserts.assert(goog.isDef(this.originY_),
'this.originY_ should be defined');
goog.asserts.assert(goog.isDef(this.rotateWithView_),
'this.rotateWithView_ should be defined');
goog.asserts.assert(goog.isDef(this.rotation_),
'this.rotation_ should be defined');
goog.asserts.assert(goog.isDef(this.scale_),
'this.scale_ should be defined');
goog.asserts.assert(goog.isDef(this.width_),
'this.width_ should be defined');
this.beginGeometry(pointGeometry, feature);
var flatCoordinates = pointGeometry.getFlatCoordinates();
var stride = pointGeometry.getStride();
@@ -809,16 +848,26 @@ ol.render.canvas.ImageReplay.prototype.drawMultiPointGeometry =
if (goog.isNull(this.image_)) {
return;
}
goog.asserts.assert(goog.isDef(this.anchorX_));
goog.asserts.assert(goog.isDef(this.anchorY_));
goog.asserts.assert(goog.isDef(this.height_));
goog.asserts.assert(goog.isDef(this.opacity_));
goog.asserts.assert(goog.isDef(this.originX_));
goog.asserts.assert(goog.isDef(this.originY_));
goog.asserts.assert(goog.isDef(this.rotateWithView_));
goog.asserts.assert(goog.isDef(this.rotation_));
goog.asserts.assert(goog.isDef(this.scale_));
goog.asserts.assert(goog.isDef(this.width_));
goog.asserts.assert(goog.isDef(this.anchorX_),
'this.anchorX_ should be defined');
goog.asserts.assert(goog.isDef(this.anchorY_),
'this.anchorY_ should be defined');
goog.asserts.assert(goog.isDef(this.height_),
'this.height_ should be defined');
goog.asserts.assert(goog.isDef(this.opacity_),
'this.opacity_ should be defined');
goog.asserts.assert(goog.isDef(this.originX_),
'this.originX_ should be defined');
goog.asserts.assert(goog.isDef(this.originY_),
'this.originY_ should be defined');
goog.asserts.assert(goog.isDef(this.rotateWithView_),
'this.rotateWithView_ should be defined');
goog.asserts.assert(goog.isDef(this.rotation_),
'this.rotation_ should be defined');
goog.asserts.assert(goog.isDef(this.scale_),
'this.scale_ should be defined');
goog.asserts.assert(goog.isDef(this.width_),
'this.width_ should be defined');
this.beginGeometry(multiPointGeometry, feature);
var flatCoordinates = multiPointGeometry.getFlatCoordinates();
var stride = multiPointGeometry.getStride();
@@ -870,17 +919,19 @@ ol.render.canvas.ImageReplay.prototype.finish = function() {
* @inheritDoc
*/
ol.render.canvas.ImageReplay.prototype.setImageStyle = function(imageStyle) {
goog.asserts.assert(!goog.isNull(imageStyle));
goog.asserts.assert(!goog.isNull(imageStyle),
'imageStyle should not be null');
var anchor = imageStyle.getAnchor();
goog.asserts.assert(!goog.isNull(anchor));
goog.asserts.assert(!goog.isNull(anchor), 'anchor should not be null');
var size = imageStyle.getSize();
goog.asserts.assert(!goog.isNull(size));
goog.asserts.assert(!goog.isNull(size), 'size should not be null');
var hitDetectionImage = imageStyle.getHitDetectionImage(1);
goog.asserts.assert(!goog.isNull(hitDetectionImage));
goog.asserts.assert(!goog.isNull(hitDetectionImage),
'hitDetectionImage should not be null');
var image = imageStyle.getImage(1);
goog.asserts.assert(!goog.isNull(image));
goog.asserts.assert(!goog.isNull(image), 'image should not be null');
var origin = imageStyle.getOrigin();
goog.asserts.assert(!goog.isNull(origin));
goog.asserts.assert(!goog.isNull(origin), 'origin should not be null');
this.anchorX_ = anchor[0];
this.anchorY_ = anchor[1];
this.hitDetectionImage_ = hitDetectionImage;
@@ -994,12 +1045,13 @@ ol.render.canvas.LineStringReplay.prototype.setStrokeStyle_ = function() {
var lineJoin = state.lineJoin;
var lineWidth = state.lineWidth;
var miterLimit = state.miterLimit;
goog.asserts.assert(goog.isDef(strokeStyle));
goog.asserts.assert(goog.isDef(lineCap));
goog.asserts.assert(!goog.isNull(lineDash));
goog.asserts.assert(goog.isDef(lineJoin));
goog.asserts.assert(goog.isDef(lineWidth));
goog.asserts.assert(goog.isDef(miterLimit));
goog.asserts.assert(goog.isDef(strokeStyle),
'strokeStyle should be defined');
goog.asserts.assert(goog.isDef(lineCap), 'lineCap should be defined');
goog.asserts.assert(!goog.isNull(lineDash), 'lineDash should not be null');
goog.asserts.assert(goog.isDef(lineJoin), 'lineJoin should be defined');
goog.asserts.assert(goog.isDef(lineWidth), 'lineWidth should be defined');
goog.asserts.assert(goog.isDef(miterLimit), 'miterLimit should be defined');
if (state.currentStrokeStyle != strokeStyle ||
state.currentLineCap != lineCap ||
!goog.array.equals(state.currentLineDash, lineDash) ||
@@ -1031,7 +1083,7 @@ ol.render.canvas.LineStringReplay.prototype.setStrokeStyle_ = function() {
ol.render.canvas.LineStringReplay.prototype.drawLineStringGeometry =
function(lineStringGeometry, feature) {
var state = this.state_;
goog.asserts.assert(!goog.isNull(state));
goog.asserts.assert(!goog.isNull(state), 'state should not be null');
var strokeStyle = state.strokeStyle;
var lineWidth = state.lineWidth;
if (!goog.isDef(strokeStyle) || !goog.isDef(lineWidth)) {
@@ -1059,7 +1111,7 @@ ol.render.canvas.LineStringReplay.prototype.drawLineStringGeometry =
ol.render.canvas.LineStringReplay.prototype.drawMultiLineStringGeometry =
function(multiLineStringGeometry, feature) {
var state = this.state_;
goog.asserts.assert(!goog.isNull(state));
goog.asserts.assert(!goog.isNull(state), 'state should not be null');
var strokeStyle = state.strokeStyle;
var lineWidth = state.lineWidth;
if (!goog.isDef(strokeStyle) || !goog.isDef(lineWidth)) {
@@ -1091,7 +1143,7 @@ ol.render.canvas.LineStringReplay.prototype.drawMultiLineStringGeometry =
*/
ol.render.canvas.LineStringReplay.prototype.finish = function() {
var state = this.state_;
goog.asserts.assert(!goog.isNull(state));
goog.asserts.assert(!goog.isNull(state), 'state should not be null');
if (state.lastStroke != this.coordinates.length) {
this.instructions.push([ol.render.canvas.Instruction.STROKE]);
}
@@ -1105,9 +1157,11 @@ ol.render.canvas.LineStringReplay.prototype.finish = function() {
*/
ol.render.canvas.LineStringReplay.prototype.setFillStrokeStyle =
function(fillStyle, strokeStyle) {
goog.asserts.assert(!goog.isNull(this.state_));
goog.asserts.assert(goog.isNull(fillStyle));
goog.asserts.assert(!goog.isNull(strokeStyle));
goog.asserts.assert(!goog.isNull(this.state_),
'this.state_ should not be null');
goog.asserts.assert(goog.isNull(fillStyle), 'fillStyle should be null');
goog.asserts.assert(!goog.isNull(strokeStyle),
'strokeStyle should not be null');
var strokeStyleColor = strokeStyle.getColor();
this.state_.strokeStyle = ol.color.asString(!goog.isNull(strokeStyleColor) ?
strokeStyleColor : ol.render.canvas.defaultStrokeStyle);
@@ -1223,7 +1277,8 @@ ol.render.canvas.PolygonReplay.prototype.drawFlatCoordinatess_ =
this.instructions.push(fillInstruction);
}
if (goog.isDef(state.strokeStyle)) {
goog.asserts.assert(goog.isDef(state.lineWidth));
goog.asserts.assert(goog.isDef(state.lineWidth),
'state.lineWidth should be defined');
var strokeInstruction = [ol.render.canvas.Instruction.STROKE];
this.instructions.push(strokeInstruction);
this.hitDetectionInstructions.push(strokeInstruction);
@@ -1238,14 +1293,15 @@ ol.render.canvas.PolygonReplay.prototype.drawFlatCoordinatess_ =
ol.render.canvas.PolygonReplay.prototype.drawCircleGeometry =
function(circleGeometry, feature) {
var state = this.state_;
goog.asserts.assert(!goog.isNull(state));
goog.asserts.assert(!goog.isNull(state), 'state should not be null');
var fillStyle = state.fillStyle;
var strokeStyle = state.strokeStyle;
if (!goog.isDef(fillStyle) && !goog.isDef(strokeStyle)) {
return;
}
if (goog.isDef(strokeStyle)) {
goog.asserts.assert(goog.isDef(state.lineWidth));
goog.asserts.assert(goog.isDef(state.lineWidth),
'state.lineWidth should be defined');
}
this.setFillStrokeStyles_();
this.beginGeometry(circleGeometry, feature);
@@ -1274,7 +1330,8 @@ ol.render.canvas.PolygonReplay.prototype.drawCircleGeometry =
this.instructions.push(fillInstruction);
}
if (goog.isDef(state.strokeStyle)) {
goog.asserts.assert(goog.isDef(state.lineWidth));
goog.asserts.assert(goog.isDef(state.lineWidth),
'state.lineWidth should be defined');
var strokeInstruction = [ol.render.canvas.Instruction.STROKE];
this.instructions.push(strokeInstruction);
this.hitDetectionInstructions.push(strokeInstruction);
@@ -1289,14 +1346,15 @@ ol.render.canvas.PolygonReplay.prototype.drawCircleGeometry =
ol.render.canvas.PolygonReplay.prototype.drawPolygonGeometry =
function(polygonGeometry, feature) {
var state = this.state_;
goog.asserts.assert(!goog.isNull(state));
goog.asserts.assert(!goog.isNull(state), 'state should not be null');
var fillStyle = state.fillStyle;
var strokeStyle = state.strokeStyle;
if (!goog.isDef(fillStyle) && !goog.isDef(strokeStyle)) {
return;
}
if (goog.isDef(strokeStyle)) {
goog.asserts.assert(goog.isDef(state.lineWidth));
goog.asserts.assert(goog.isDef(state.lineWidth),
'state.lineWidth should be defined');
}
this.setFillStrokeStyles_();
this.beginGeometry(polygonGeometry, feature);
@@ -1324,14 +1382,15 @@ ol.render.canvas.PolygonReplay.prototype.drawPolygonGeometry =
ol.render.canvas.PolygonReplay.prototype.drawMultiPolygonGeometry =
function(multiPolygonGeometry, feature) {
var state = this.state_;
goog.asserts.assert(!goog.isNull(state));
goog.asserts.assert(!goog.isNull(state), 'state should not be null');
var fillStyle = state.fillStyle;
var strokeStyle = state.strokeStyle;
if (!goog.isDef(fillStyle) && !goog.isDef(strokeStyle)) {
return;
}
if (goog.isDef(strokeStyle)) {
goog.asserts.assert(goog.isDef(state.lineWidth));
goog.asserts.assert(goog.isDef(state.lineWidth),
'state.lineWidth should be defined');
}
this.setFillStrokeStyles_();
this.beginGeometry(multiPolygonGeometry, feature);
@@ -1362,7 +1421,8 @@ ol.render.canvas.PolygonReplay.prototype.drawMultiPolygonGeometry =
* @inheritDoc
*/
ol.render.canvas.PolygonReplay.prototype.finish = function() {
goog.asserts.assert(!goog.isNull(this.state_));
goog.asserts.assert(!goog.isNull(this.state_),
'this.state_ should not be null');
this.reverseHitDetectionInstructions_();
this.state_ = null;
// We want to preserve topology when drawing polygons. Polygons are
@@ -1400,8 +1460,10 @@ ol.render.canvas.PolygonReplay.prototype.getBufferedMaxExtent = function() {
*/
ol.render.canvas.PolygonReplay.prototype.setFillStrokeStyle =
function(fillStyle, strokeStyle) {
goog.asserts.assert(!goog.isNull(this.state_));
goog.asserts.assert(!goog.isNull(fillStyle) || !goog.isNull(strokeStyle));
goog.asserts.assert(!goog.isNull(this.state_),
'this.state_ should not be null');
goog.asserts.assert(!goog.isNull(fillStyle) || !goog.isNull(strokeStyle),
'fillStyle or strokeStyle should not be null');
var state = this.state_;
if (!goog.isNull(fillStyle)) {
var fillStyleColor = fillStyle.getColor();
@@ -1464,11 +1526,11 @@ ol.render.canvas.PolygonReplay.prototype.setFillStrokeStyles_ = function() {
state.currentFillStyle = state.fillStyle;
}
if (goog.isDef(strokeStyle)) {
goog.asserts.assert(goog.isDef(lineCap));
goog.asserts.assert(!goog.isNull(lineDash));
goog.asserts.assert(goog.isDef(lineJoin));
goog.asserts.assert(goog.isDef(lineWidth));
goog.asserts.assert(goog.isDef(miterLimit));
goog.asserts.assert(goog.isDef(lineCap), 'lineCap should be defined');
goog.asserts.assert(!goog.isNull(lineDash), 'lineDash should not be null');
goog.asserts.assert(goog.isDef(lineJoin), 'lineJoin should be defined');
goog.asserts.assert(goog.isDef(lineWidth), 'lineWidth should be defined');
goog.asserts.assert(goog.isDef(miterLimit), 'miterLimit should be defined');
if (state.currentStrokeStyle != strokeStyle ||
state.currentLineCap != lineCap ||
state.currentLineDash != lineDash ||
@@ -1942,7 +2004,8 @@ ol.render.canvas.ReplayGroup.prototype.getReplay =
var replay = replays[replayType];
if (!goog.isDef(replay)) {
var Constructor = ol.render.canvas.BATCH_CONSTRUCTORS_[replayType];
goog.asserts.assert(goog.isDef(Constructor));
goog.asserts.assert(goog.isDef(Constructor),
'Constructor should be defined');
replay = new Constructor(this.tolerance_, this.maxExtent_,
this.resolution_);
replays[replayType] = replay;

33
src/ol/render/vector.js
View File

@@ -54,7 +54,8 @@ ol.renderer.vector.getTolerance = function(resolution, pixelRatio) {
*/
ol.renderer.vector.renderCircleGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.Circle);
goog.asserts.assertInstanceof(geometry, ol.geom.Circle,
'geometry should be an ol.geom.Circle');
var fillStyle = style.getFill();
var strokeStyle = style.getStroke();
if (!goog.isNull(fillStyle) || !goog.isNull(strokeStyle)) {
@@ -98,7 +99,8 @@ ol.renderer.vector.renderFeature = function(
imageStyle.load();
}
imageState = imageStyle.getImageState();
goog.asserts.assert(imageState == ol.style.ImageState.LOADING);
goog.asserts.assert(imageState == ol.style.ImageState.LOADING,
'imageState should be LOADING');
imageStyle.listenImageChange(listener, thisArg);
loading = true;
}
@@ -125,7 +127,8 @@ ol.renderer.vector.renderFeature_ = function(
var simplifiedGeometry = geometry.getSimplifiedGeometry(squaredTolerance);
var geometryRenderer =
ol.renderer.vector.GEOMETRY_RENDERERS_[simplifiedGeometry.getType()];
goog.asserts.assert(goog.isDef(geometryRenderer));
goog.asserts.assert(goog.isDef(geometryRenderer),
'geometryRenderer should be defined');
geometryRenderer(replayGroup, simplifiedGeometry, style, feature);
};
@@ -139,13 +142,15 @@ ol.renderer.vector.renderFeature_ = function(
*/
ol.renderer.vector.renderGeometryCollectionGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.GeometryCollection);
goog.asserts.assertInstanceof(geometry, ol.geom.GeometryCollection,
'geometry should be an ol.geom.GeometryCollection');
var geometries = geometry.getGeometriesArray();
var i, ii;
for (i = 0, ii = geometries.length; i < ii; ++i) {
var geometryRenderer =
ol.renderer.vector.GEOMETRY_RENDERERS_[geometries[i].getType()];
goog.asserts.assert(goog.isDef(geometryRenderer));
goog.asserts.assert(goog.isDef(geometryRenderer),
'geometryRenderer should be defined');
geometryRenderer(replayGroup, geometries[i], style, feature);
}
};
@@ -160,7 +165,8 @@ ol.renderer.vector.renderGeometryCollectionGeometry_ =
*/
ol.renderer.vector.renderLineStringGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.LineString);
goog.asserts.assertInstanceof(geometry, ol.geom.LineString,
'geometry should be an ol.geom.LineString');
var strokeStyle = style.getStroke();
if (!goog.isNull(strokeStyle)) {
var lineStringReplay = replayGroup.getReplay(
@@ -187,7 +193,8 @@ ol.renderer.vector.renderLineStringGeometry_ =
*/
ol.renderer.vector.renderMultiLineStringGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiLineString,
'geometry should be an ol.geom.MultiLineString');
var strokeStyle = style.getStroke();
if (!goog.isNull(strokeStyle)) {
var lineStringReplay = replayGroup.getReplay(
@@ -216,7 +223,8 @@ ol.renderer.vector.renderMultiLineStringGeometry_ =
*/
ol.renderer.vector.renderMultiPolygonGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPolygon);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPolygon,
'geometry should be an ol.geom.MultiPolygon');
var fillStyle = style.getFill();
var strokeStyle = style.getStroke();
if (!goog.isNull(strokeStyle) || !goog.isNull(fillStyle)) {
@@ -246,7 +254,8 @@ ol.renderer.vector.renderMultiPolygonGeometry_ =
*/
ol.renderer.vector.renderPointGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.Point);
goog.asserts.assertInstanceof(geometry, ol.geom.Point,
'geometry should be an ol.geom.Point');
var imageStyle = style.getImage();
if (!goog.isNull(imageStyle)) {
if (imageStyle.getImageState() != ol.style.ImageState.LOADED) {
@@ -276,7 +285,8 @@ ol.renderer.vector.renderPointGeometry_ =
*/
ol.renderer.vector.renderMultiPointGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPoint);
goog.asserts.assertInstanceof(geometry, ol.geom.MultiPoint,
'geometry should be an ol.goem.MultiPoint');
var imageStyle = style.getImage();
if (!goog.isNull(imageStyle)) {
if (imageStyle.getImageState() != ol.style.ImageState.LOADED) {
@@ -308,7 +318,8 @@ ol.renderer.vector.renderMultiPointGeometry_ =
*/
ol.renderer.vector.renderPolygonGeometry_ =
function(replayGroup, geometry, style, feature) {
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon);
goog.asserts.assertInstanceof(geometry, ol.geom.Polygon,
'geometry should be an ol.geom.Polygon');
var fillStyle = style.getFill();
var strokeStyle = style.getStroke();
if (!goog.isNull(fillStyle) || !goog.isNull(strokeStyle)) {