--- a/labs/openlayers/lib/OpenLayers/Format/SOSGetFeatureOfInterest.js
+++ b/labs/openlayers/lib/OpenLayers/Format/SOSGetFeatureOfInterest.js
@@ -1,1 +1,194 @@
+/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for 
+ * full list of contributors). Published under the Clear BSD license.  
+ * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+ 
+/**
+ * @requires OpenLayers/Format/XML.js
+ * @requires OpenLayers/Format/GML/v3.js
+ */
 
+/**
+ * Class: OpenLayers.Format.SOSGetFeatureOfInterest
+ * Read and write SOS GetFeatureOfInterest. This is used to get to
+ * the location of the features (stations). The stations can have 1 or more
+ * sensors.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Format.XML>
+ */
+OpenLayers.Format.SOSGetFeatureOfInterest = OpenLayers.Class(
+    OpenLayers.Format.XML, {
+    
+    /**
+     * Constant: VERSION
+     * {String} 1.0.0
+     */
+    VERSION: "1.0.0",
+
+    /**
+     * Property: namespaces
+     * {Object} Mapping of namespace aliases to namespace URIs.
+     */
+    namespaces: {
+        sos: "http://www.opengis.net/sos/1.0",
+        gml: "http://www.opengis.net/gml",
+        sa: "http://www.opengis.net/sampling/1.0",
+        xsi: "http://www.w3.org/2001/XMLSchema-instance"
+    },
+
+    /**
+     * Property: schemaLocation
+     * {String} Schema location
+     */
+    schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosAll.xsd",
+
+    /**
+     * Property: defaultPrefix
+     */
+    defaultPrefix: "sos",
+
+    /**
+     * Property: regExes
+     * Compiled regular expressions for manipulating strings.
+     */
+    regExes: {
+        trimSpace: (/^\s*|\s*$/g),
+        removeSpace: (/\s*/g),
+        splitSpace: (/\s+/),
+        trimComma: (/\s*,\s*/g)
+    },
+    
+    /**
+     * Constructor: OpenLayers.Format.SOSGetFeatureOfInterest
+     *
+     * Parameters:
+     * options - {Object} An optional object whose properties will be set on
+     *     this instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
+    },
+
+    /**
+     * APIMethod: read
+     * Parse a GetFeatureOfInterest response and return an array of features
+     * 
+     * Parameters: 
+     * data - {String} or {DOMElement} data to read/parse.
+     *
+     * Returns:
+     * {Array(<OpenLayers.Feature.Vector>)} An array of features. 
+     */
+    read: function(data) {
+        if(typeof data == "string") {
+            data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
+        }
+        if(data && data.nodeType == 9) {
+            data = data.documentElement;
+        }
+
+        var info = {features: []};
+        this.readNode(data, info);
+       
+        var features = [];
+        for (var i=0, len=info.features.length; i<len; i++) {
+            var container = info.features[i];
+            // reproject features if needed
+            if(this.internalProjection && this.externalProjection &&
+                container.components[0]) {
+                    container.components[0].transform(
+                        this.externalProjection, this.internalProjection
+                    );
+            }             
+            var feature = new OpenLayers.Feature.Vector(
+                container.components[0], container.attributes);
+            features.push(feature);
+        }
+        return features;
+    },
+
+    /**
+     * Property: readers
+     * Contains public functions, grouped by namespace prefix, that will
+     *     be applied when a namespaced node is found matching the function
+     *     name.  The function will be applied in the scope of this parser
+     *     with two arguments: the node being read and a context object passed
+     *     from the parent.
+     */
+    readers: {
+        "sa": {
+            "SamplingPoint": function(node, obj) {
+                // sampling point can also be without a featureMember if 
+                // there is only 1
+                if (!obj.attributes) {
+                    var feature = {attributes: {}};
+                    obj.features.push(feature);
+                    obj = feature;
+                }
+                obj.attributes.id = this.getAttributeNS(node, 
+                    this.namespaces.gml, "id");
+                this.readChildNodes(node, obj);
+            },
+            "position": function (node, obj) {
+                this.readChildNodes(node, obj);
+            }
+        },
+        "gml": OpenLayers.Util.applyDefaults({
+            "FeatureCollection": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "featureMember": function(node, obj) {
+                var feature = {attributes: {}};
+                obj.features.push(feature);
+                this.readChildNodes(node, feature);
+            },
+            "name": function(node, obj) {
+                obj.attributes.name = this.getChildValue(node);
+            },
+            "pos": function(node, obj) {
+                // we need to parse the srsName to get to the 
+                // externalProjection, that's why we cannot use
+                // GML v3 for this
+                if (!this.externalProjection) {
+                    this.externalProjection = new OpenLayers.Projection(
+                        node.getAttribute("srsName"));
+                }
+             OpenLayers.Format.GML.v3.prototype.readers.gml.pos.apply(
+                    this, [node, obj]);
+            }
+        }, OpenLayers.Format.GML.v3.prototype.readers.gml)
+    },
+    
+    /**
+     * Property: writers
+     * As a compliment to the readers property, this structure contains public
+     *     writing functions grouped by namespace alias and named like the
+     *     node names they produce.
+     */
+    writers: {
+        "sos": {
+            "GetFeatureOfInterest": function(options) {
+                var node = this.createElementNSPlus("GetFeatureOfInterest", {
+                    attributes: {
+                        version: this.VERSION,
+                        service: 'SOS',
+                        "xsi:schemaLocation": this.schemaLocation
+                    } 
+                }); 
+                for (var i=0, len=options.fois.length; i<len; i++) {
+                    this.writeNode("FeatureOfInterestId", {foi: options.fois[i]}, node);
+                }
+                return node; 
+            },
+            "FeatureOfInterestId": function(options) {
+                var node = this.createElementNSPlus("FeatureOfInterestId", {value: options.foi});
+                return node;
+            }
+        }
+    },
+
+    CLASS_NAME: "OpenLayers.Format.SOSGetFeatureOfInterest" 
+
+});
+