docs: function(geometry, layer, options) {
          // set the buffer to 1 unit (dd/m/ft?) by default
          var buffer = options.buffer || 1;
          // empty callback by default
          var callback = options.callback || function() {};
          // default scope is window (global)
          var scope = options.scope || window;
  
          // apply these option to the request options
          var requestOptions = {};
          OpenLayers.Util.extend(requestOptions, this.options);
  
          // this is a feature request
          requestOptions.requesttype = "feature";
  
          if (geometry instanceof OpenLayers.LonLat) {
              // create an envelope if the geometry is really a lon/lat
              requestOptions.polygon = null;
              requestOptions.envelope = [ 
                  geometry.lon - buffer, 
                  geometry.lat - buffer,
                  geometry.lon + buffer,
                  geometry.lat + buffer
              ];
          } else if (geometry instanceof OpenLayers.Geometry.Polygon) {
              // use the polygon assigned, and empty the envelope
              requestOptions.envelope = null;
              requestOptions.polygon = geometry;
          }
        
          // create an arcxml request to get feature requests
          var arcxml = new OpenLayers.Format.ArcXML(requestOptions);
  
          // apply any get feature options to the arcxml request
          OpenLayers.Util.extend(arcxml.request.get_feature, options);
  
          arcxml.request.get_feature.layer = layer.id;
          if (typeof layer.query.accuracy == "number") {
              // set the accuracy if it was specified
              arcxml.request.get_feature.query.accuracy = layer.query.accuracy;
          } else {
              // guess that the accuracy is 1 per screen pixel
              var mapCenter = this.map.getCenter();
              var viewPx = this.map.getViewPortPxFromLonLat(mapCenter);
              viewPx.x++;
              var mapOffCenter = this.map.getLonLatFromPixel(viewPx);
              arcxml.request.get_feature.query.accuracy = mapOffCenter.lon - mapCenter.lon;
          }
          
          // set the get_feature query to be the same as the layer passed in
          arcxml.request.get_feature.query.where = layer.query.where;
          
          // use area_intersection
          arcxml.request.get_feature.query.spatialfilter.relation = "area_intersection";
        
          // create a new asynchronous request to get the feature info
          OpenLayers.Request.POST({
              url: this.getFullRequestString({'CustomService': 'Query'}),
              data: arcxml.write(),
              callback: function(request) {
                  // parse the arcxml response
                  var response = arcxml.parseResponse(request.responseText);
                  
                  if (!arcxml.iserror()) {
                      // if the arcxml is not an error, call the callback with the features parsed
                      callback.call(scope, response.features);
                  } else {
                      // if the arcxml is an error, return null features selected
                      callback.call(scope, null);
                  }
              }
          });
      }