Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | 24x 24x 24x 24x 1x 8x 8x 2x 6x 6x 7x 5x 1x 21x 1x 1x 13x 13x 13x 3x 10x 10x 9x 10x 10x 10x 17x 17x 17x 16x 16x 17x 10x 10x 1x 35x 35x 35x 21x 21x 21x 36x 36x 36x 14x 35x 1x 5x 1x 13x | import defined from "../Core/defined.js";
import Event from "../Core/Event.js";
import EventHelper from "../Core/EventHelper.js";
import JulianDate from "../Core/JulianDate.js";
import Property from "./Property.js";
/**
* A {@link Property} whose value is an array whose items are the computed value
* of other property instances.
*
* @alias PropertyArray
* @constructor
*
* @param {Property[]} [value] An array of Property instances.
*/
function PropertyArray(value) {
this._value = undefined;
this._definitionChanged = new Event();
this._eventHelper = new EventHelper();
this.setValue(value);
}
Object.defineProperties(PropertyArray.prototype, {
/**
* Gets a value indicating if this property is constant. This property
* is considered constant if all property items in the array are constant.
* @memberof PropertyArray.prototype
*
* @type {boolean}
* @readonly
*/
isConstant: {
get: function () {
const value = this._value;
if (!defined(value)) {
return true;
}
const length = value.length;
for (let i = 0; i < length; i++) {
if (!Property.isConstant(value[i])) {
return false;
}
}
return true;
},
},
/**
* Gets the event that is raised whenever the definition of this property changes.
* The definition is changed whenever setValue is called with data different
* than the current value or one of the properties in the array also changes.
* @memberof PropertyArray.prototype
*
* @type {Event}
* @readonly
*/
definitionChanged: {
get: function () {
return this._definitionChanged;
},
},
});
const timeScratch = new JulianDate();
/**
* Gets the value of the property.
*
* @param {JulianDate} [time=JulianDate.now()] The time for which to retrieve the value. If omitted, the current system time is used.
* @param {object[]} [result] The object to store the value into, if omitted, a new instance is created and returned.
* @returns {object[]} The modified result parameter, which is an array of values produced by evaluating each of the contained properties at the given time or a new instance if the result parameter was not supplied.
*/
PropertyArray.prototype.getValue = function (time, result) {
Iif (!defined(time)) {
time = JulianDate.now(timeScratch);
}
const value = this._value;
if (!defined(value)) {
return undefined;
}
const length = value.length;
if (!defined(result)) {
result = new Array(length);
}
let i = 0;
let x = 0;
while (i < length) {
const property = this._value[i];
const itemValue = property.getValue(time, result[i]);
if (defined(itemValue)) {
result[x] = itemValue;
x++;
}
i++;
}
result.length = x;
return result;
};
/**
* Sets the value of the property.
*
* @param {Property[]} value An array of Property instances.
*/
PropertyArray.prototype.setValue = function (value) {
const eventHelper = this._eventHelper;
eventHelper.removeAll();
if (defined(value)) {
this._value = value.slice();
const length = value.length;
for (let i = 0; i < length; i++) {
const property = value[i];
Eif (defined(property)) {
eventHelper.add(
property.definitionChanged,
PropertyArray.prototype._raiseDefinitionChanged,
this,
);
}
}
} else {
this._value = undefined;
}
this._definitionChanged.raiseEvent(this);
};
/**
* Compares this property to the provided property and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Property} [other] The other property.
* @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
PropertyArray.prototype.equals = function (other) {
return (
this === other || //
(other instanceof PropertyArray && //
Property.arrayEquals(this._value, other._value))
);
};
PropertyArray.prototype._raiseDefinitionChanged = function () {
this._definitionChanged.raiseEvent(this);
};
export default PropertyArray;
|