Set the featureModel.

@param featureModel
feature model
@throws LayerException
problem setting the feature model
@since 1.8.0
182377
@Api
	public void setFeatureModel(FeatureModel featureModel) throws LayerException {
		this.featureModel = featureModel;
		if (null != getLayerInfo()) {
			featureModel.setLayerInfo(getLayerInfo());
		}
		filterService.registerFeatureModel(featureModel);
	}
653848
public void setLayer(VectorLayer layer) {
		this.layer = layer;
		Object value = layerSelect.getValue();
		if (value == null || !value.equals(layer.getLabel())) {
			layerSelect.setValue(layer.getLabel());
		}
		empty();
	}
954740
public void setCacheMode(CacheMode mode) {
        if (mode == null)
            mode = CacheMode.NONE;

        for (Layer layer : layers) {
            layer.setCacheMode(mode);
        }
    }
387083
protected static void addFeatureThenClear(StringBuilder rawFeature, List<Integer> featureVector, FeatureMap featureMap)
    {
        int id = featureMap.idOf(rawFeature.toString());
        if (id != -1)
        {
            featureVector.add(id);
        }
        rawFeature.setLength(0);
    }
142329
public void setModel (PropertySheetModel pm)
  {
    if (pm instanceof org.apache.ojb.tools.mapping.reversedb.DBColumn)
    {
      this.aColumn = (org.apache.ojb.tools.mapping.reversedb.DBColumn)pm;
      this.readValuesFromColumn();
    }
    else
      throw new IllegalArgumentException();    
  }
128602
public void setCriterion(Criterion criterion) {
		this.criterion = criterion;

		// Replace the handler if it is of type featureList 
		// (when we have a criterion it is better to use that as it has no limitation on returned items)
		if (exportCsvHandler == null || exportCsvHandler instanceof ExportFeatureListToCsvHandler) {
			this.exportCsvHandler = new ExportSearchToCsvHandler(mapWidget.getMapModel(), layer, criterion);
		} else if (exportCsvHandler instanceof ExportSearchToCsvHandler) {
			((ExportSearchToCsvHandler) exportCsvHandler).setCriterion(criterion);
		}
	}
703361
public void setModelByText(String model) {
        try {
            InputStream is = new ByteArrayInputStream(model.getBytes());
            this.model = SCXMLParser.parse(new InputSource(is), null, customActionsFromTagExtensions());
            this.setStateMachine(this.model);
        } catch (IOException | SAXException | ModelException e) {
            e.printStackTrace();
        }
    }
728115
public void setSceneModel (MisoSceneModel model)
    {
        _model = model;

        // clear out old blocks and objects
        clearScene();

        centerOnTile(0, 0);
        if (isShowing()) {
            rethink();
            _remgr.invalidateRegion(_vbounds);
        }
    }
320671
function(layerModel, leafletLayer, leafletMap) {
    this.leafletLayer = leafletLayer;
    this.leafletMap = leafletMap;
    this.model = layerModel;

    this.setModel(layerModel);

    this.type = layerModel.get('type') || layerModel.get('kind');
    this.type = this.type.toLowerCase();
  }
102920
@Override
    public void setModel(final TableModel dataModel) {
        super.setModel(dataModel);
        if (_panel != null) {
            _panel.updateUI();
        }
    }
20588
static void setModelValue(final ModelNode model, final String value) {
        if (value != null) {
            model.set(value);
        }
    }
939704
function(layerModel, gmapsMap) {
  var self = this;

  _.bindAll(this, 'featureOut', 'featureOver', 'featureClick');

  var opts = _.clone(layerModel.attributes);

  opts.map =  gmapsMap;

  var // preserve the user's callbacks
  _featureOver  = opts.featureOver,
  _featureOut   = opts.featureOut,
  _featureClick = opts.featureClick;

  opts.featureOver  = function() {
    _featureOver  && _featureOver.apply(this, arguments);
    self.featureOver  && self.featureOver.apply(this, arguments);
  };

  opts.featureOut  = function() {
    _featureOut  && _featureOut.apply(this, arguments);
    self.featureOut  && self.featureOut.apply(this, arguments);
  };

  opts.featureClick  = function() {
    _featureClick  && _featureClick.apply(this, arguments);
    self.featureClick  && self.featureClick.apply(opts, arguments);
  };

  cdb.geo.CartoDBLayerGMaps.call(this, opts);
  cdb.geo.GMapsLayerView.call(this, layerModel, this, gmapsMap);
}
365056
@Override
    public void setFeature(String featureId, boolean value)
            throws SAXNotRecognizedException, SAXNotSupportedException {
        boolean state;

        // Features with a defined value, we just change it if we can.
        state = getFeature(featureId);

        if (state == value) {
            return;
        }
        if (parser != null) {
            throw new SAXNotSupportedException("not while parsing");
        }

        if ((FEATURE + "namespace-prefixes").equals(featureId)) {
            // in this implementation, this only affects xmlns reporting
            xmlNames = value;
            // forcibly prevent illegal parser state
            if (!xmlNames) {
                namespaces = true;
            }
            return;
        }

        if ((FEATURE + "namespaces").equals(featureId)) {
            namespaces = value;
            // forcibly prevent illegal parser state
            if (!namespaces) {
                xmlNames = true;
            }
            return;
        }

        if ((FEATURE + "external-general-entities").equals(featureId)) {
            extGE = value;
            return;
        }
        if ((FEATURE + "external-parameter-entities").equals(featureId)) {
            extPE = value;
            return;
        }
        if ((FEATURE + "resolve-dtd-uris").equals(featureId)) {
            resolveAll = value;
            return;
        }

        if ((FEATURE + "use-entity-resolver2").equals(featureId)) {
            useResolver2 = value;
            return;
        }

        if ("http://xml.org/sax/features/unicode-normalization-checking".equals(featureId)) {
            checkNormalization = value;
            return;
        }

        throw new SAXNotRecognizedException(featureId);
    }
168397
@Override
	public void setLayerInfo(VectorLayerInfo layerInfo) throws LayerException {
		super.setLayerInfo(layerInfo);
		srid = geoService.getSridFromCrs(layerInfo.getCrs());
		entityMapper = new HibernateEntityMapper(getSessionFactory());
	}
205386
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
	private void initLayerType() {
		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
			setLayerType(LAYER_TYPE_SOFTWARE, getPaint());
			LOGGER.trace("Initialized the layer type");
		}
	}
1121349
@Override
	public Feature create(org.geomajas.layer.feature.Feature feature, FeaturesSupported layer) {
		Map<String, Attribute<?>> attributes = new HashMap<String, Attribute<?>>();
		for (String key : feature.getAttributes().keySet()) {
			attributes.put(key, new AttributeImpl(feature.getAttributes().get(key)));
		}
		return new FeatureImpl(layer, feature.getId(), attributes, feature.getGeometry(), feature.getLabel());
	}
571445
public void addFeatures(Collection<String> featuresToAdd) {
        if (featuresToAdd == null) return;
        for (String feature : featuresToAdd) {
            addFeature(feature);
        }
    }