Set up features which are maintained over time, using their ids.
Only appropriate if there is a time column and idColumns are specified.
@private
428824
function setOneFeaturePerId(dataSource, tableStructure, specialColumns) {
  var legendHelper = dataSource._legendHelper;
  var tableColumnStyle = legendHelper.tableColumnStyle;
  var fallbackNameField = chooseFallbackNameField(
    tableStructure.getColumnNames(),
    tableStructure.idColumnNames
  );
  var rowNumbersMap = tableStructure.getIdMapping();
  var columnAliases = tableStructure.getColumnAliases();
  var isSampled = tableStructure.isSampled;
  var shouldInterpolateColorAndSize =
    isSampled &&
    (defined(specialColumns.value) && !specialColumns.value.isEnum);

  if (dataSource._hasFeaturePerRow) {
    // If for any reason features were set up per row already (eg. if time column was set after first load),
    // remove those features.
    dataSource._entityCollection.removeAll();
  }

  function getChartDetailsFunction(tableStructure, rowNumbersForThisFeatureId) {
    return function() {
      return tableStructure.getChartDetailsForRowNumbers(
        rowNumbersForThisFeatureId
      );
    };
  }

  for (var key in rowNumbersMap) {
    if (rowNumbersMap.hasOwnProperty(key)) {
      var firstRow = dataSource._rowObjects[rowNumbersMap[key][0]].string;
      var featureId = dataSource._guid + "-" + key;
      var feature = dataSource._entityCollection.getById(featureId);
      var isExistingFeature = defined(feature);
      if (!isExistingFeature) {
        feature = new Feature({
          id: featureId,
          name:
            firstRow.title || firstRow[fallbackNameField] || defaultFeatureName
        });
      }
      var availability = new TimeIntervalCollection();

      var position;
      if (isSampled) {
        position = new SampledPositionProperty();
      } else {
        position = new TimeIntervalCollectionPositionProperty();
      }
      // Color and size are never interpolated when they are drawn from a text column.
      var color, scale, pixelSize;
      if (shouldInterpolateColorAndSize) {
        color = new SampledProperty(Color);
        scale = new SampledProperty(Number);
        pixelSize = new SampledProperty(Number);
      } else {
        color = new TimeIntervalCollectionProperty();
        scale = new TimeIntervalCollectionProperty();
        pixelSize = new TimeIntervalCollectionProperty();
      }
      var properties = new TimeIntervalCollectionProperty();
      var description = new TimeIntervalCollectionProperty();

      var rowNumbersForThisFeatureId = rowNumbersMap[key];
      var chartDetailsFunction = getChartDetailsFunction(
        tableStructure,
        rowNumbersForThisFeatureId
      );
      for (var i = 0; i < rowNumbersForThisFeatureId.length; i++) {
        var rowNumber = rowNumbersForThisFeatureId[i];
        var point = getPositionOfRowNumber(specialColumns, rowNumber);
        var interval = specialColumns.time.timeIntervals[rowNumber];
        availability.addInterval(interval);

        // Add the feature properties.
        var propertiesInterval = interval.clone();
        propertiesInterval.data = dataSource._rowObjects[rowNumber].string;
        propertiesInterval.data._terria_columnAliases = columnAliases;
        propertiesInterval.data._terria_numericalProperties =
          dataSource._rowObjects[rowNumber].number;
        if (defined(rowNumbersForThisFeatureId)) {
          propertiesInterval.data._terria_getChartDetails = chartDetailsFunction;
        }

        properties.intervals.addInterval(propertiesInterval);

        // Add the feature description.
        var descriptionInterval = interval.clone();
        descriptionInterval.data = dataSource._rowDescriptions[rowNumber];
        description.intervals.addInterval(descriptionInterval);

        // Add the feature position.
        if (isSampled) {
          if (defined(point)) {
            position.addSample(
              specialColumns.time.julianDates[rowNumber],
              point
            );
          }
        } else {
          var positionInterval = interval.clone();
          positionInterval.data = point;
          position.intervals.addInterval(positionInterval);
        }

        // Add the feature color, scale and pixelSize.
        var value = defined(specialColumns.value)
          ? specialColumns.value.values[rowNumber]
          : undefined;
        if (shouldInterpolateColorAndSize) {
          var julianDate = specialColumns.time.julianDates[rowNumber];
          color.addSample(julianDate, legendHelper.getColorFromValue(value));
          scale.addSample(julianDate, legendHelper.getScaleFromValue(value));
          pixelSize.addSample(
            julianDate,
            legendHelper.getScaleFromValue(value) * 8
          );
        } else {
          var colorInterval = interval.clone();
          var scaleInterval = interval.clone();
          var pixelSizeInterval = interval.clone();
          colorInterval.data = legendHelper.getColorFromValue(value);
          scaleInterval.data = legendHelper.getScaleFromValue(value);
          pixelSizeInterval.data = legendHelper.getScaleFromValue(value) * 8;
          color.intervals.addInterval(colorInterval);
          scale.intervals.addInterval(scaleInterval);
          pixelSize.intervals.addInterval(pixelSizeInterval);
        }
      }
      // We show this feature only when the time intervals say to.
      // Note this means a missing data point for one feature will make it disappear
      // for that period, not be interpolated.
      // We could enhance this by adding a TableStructure version of the TableColumn
      // timeInterval calculation, which uses idColumnNames and works per-feature.
      var show = calculateShow(availability);
      // Update the feature in as few commands as possible, since each one triggers a definitionChanged event.
      feature.availability = availability;
      feature.position = position;
      feature.properties = properties;
      feature.description = description;
      // Turn the color, scale, pixelSize and "show" into a Cesium entity.
      addPointToEntity(
        feature,
        tableColumnStyle,
        scale,
        pixelSize,
        color,
        show
      );
      if (!isExistingFeature) {
        dataSource._entityCollection.add(feature);
      }
    }
  }
}
138824
function (id, vals) {
      var custom = later.modifier[id];
      if(!custom) throw new Error('Custom modifier ' + id + ' not recognized!');

      modifier = id;
      values = arguments[1] instanceof Array ? arguments[1] : [arguments[1]];
      return this;
    }
585517
function onSetPersistence() {
  var type = $('#persistence-type').val();
  try {
    auth.setPersistence(type).then(function() {
      log('Persistence state change to "' + type + '".');
      alertSuccess('Persistence state change to "' + type + '".');
    }, function(error) {
      alertError('Error: ' + error.code);
    });
  } catch (error) {
    alertError('Error: ' + error.code);
  }
}
927883
protected void ensureColumns(List columns, List existingColumns)
    {
        if (columns == null || columns.isEmpty())
        {
            return;
        }
        
        Iterator iter = columns.iterator();

        while (iter.hasNext())
        {
            FieldHelper cf = (FieldHelper) iter.next();
            if (!existingColumns.contains(cf.name))
            {
                getAttributeInfo(cf.name, false, null, getQuery().getPathClasses());
            }
        }
    }
1146544
def set_feature_generator(self):
        """"""
        self.features = preparation.build_peptidetable(self.lookup,
                                                       self.headerfields,
                                                       self.isobaric,
                                                       self.precursor,
                                                       self.fdr, self.pep,
                                                       self.genecentric)
1210255
function(id){
        if(id){
            var plugins = this.doc.findall('./plugin/[@name="' + id + '"]')
                .concat(this.doc.findall('./feature/param[@name="id"][@value="' + id + '"]/..'));
            var children = this.doc.getroot().getchildren();
            plugins.forEach(function (plugin) {
                var idx = children.indexOf(plugin);
                if (idx > -1) {
                    children.splice(idx, 1);
                }
            });
        }
    }
1245325
private void setObjectDefaults(DigitalObject obj) {
        if (obj.getCreateDate() == null) obj.setCreateDate(m_now);
        if (obj.getLastModDate() == null) obj.setLastModDate(m_now);

        Iterator<String> dsIds = obj.datastreamIdIterator();
        while (dsIds.hasNext()) {
            String dsid = dsIds.next();
            for (Datastream ds : obj.datastreams(dsid)) {
                ds.DSSize = 0;
                if (ds.DSCreateDT == null) {
                    ds.DSCreateDT = m_now;
                }
            }
        }
    }
690093
function(fields, visible) {
        if (!$.isArray(fields)) {
            fields = [fields];
        }
        var self = this;
        $.each(fields, function(index, field) {
            $.each(self.options.column, function(i, col) {
                if (col.field === field) {
                    col.visible = visible;
                }
            });
        });
        this.refresh();
    }
1076613
function(storage) {

		this._data_uids = storage.uids;
		this._data_values = storage.values;
		this._data_names = storage.names;

	}
328624
function (id) {
      var custom = later[id];
      if(!custom) throw new Error('Custom time period ' + id + ' not recognized!');

      add(id, custom.extent(new Date())[0], custom.extent(new Date())[1]);
      return this;
    }
791611
function (data) {
    // Add property to hold internal values
    Object.defineProperty(this, '_', {
        enumerable: false,
        configurable: false,
        writable: false,
        value: {
            dt: this._clone(data),
            ev: {},
            df: {},
            sp: false,
            ct: 0
        }
    });
    // Assign keys
    for (var key in this._.dt) {
        this._addProperty(key);
    }
}
315316
function initGridCompColumn() {
    var oThis = this;
    this.initGridCompColumnVar();
    if (this.options.columns) {
        $.each(this.options.columns, function (i) {
            oThis.initGridCompColumnFun(this);
        });
    }
    this.initGridCompColumnLoacl();
    this.initGridHiddenLevelColumn();
    this.initGridCompFixedColumn();
    this.columnsVisibleFun();
}
763999
public function autosetColumns()
    {
        $value = $this->value;
        if (empty($this->columns)) {
            $dataValue = $value;
            if (count($dataValue)) {
                $firstValue = (array) $dataValue[0];
                foreach (array_keys($firstValue) as $header) {
                    $this->addColumn($header);
                }
            }
        }
    }
526272
function () {
        this._patterns
            .map(pattern => this._getPatternLayers(pattern))
            .forEach(layers => { this.addLayer(L.featureGroup(layers)); });
    }
990685
function updateVisibility(tr, ids) {
  let display = 'none';
  ids.forEach(function(id) {
    if(id.includes(idFilter.value)) {
      display = '';
    }
  });
  tr.style.display = display;
}
1015037
protected function _setup()
    {
        parent::_setup();

        $this->_setupPrimaryAssignment();
        $this->setLifetime($this->_lifetime);

        $this->_checkRequiredColumns();
    }
235474
function( elem, options, callback ) {
		var old = {};

		// Remember the old values, and insert the new ones
		for ( var name in options ) {
			old[ name ] = elem.style[ name ];
			elem.style[ name ] = options[ name ];
		}

		callback.call( elem );

		// Revert the old values
		for ( var name in options ) {
			elem.style[ name ] = old[ name ];
		}
	}