Example #1
0
        private DataValue CreateAppropriateDataValue(String attributeName, Object attributeValue)
        {
            DataValue dv = null;

            String t = _simModel.objectModel.objects["PhysicalObject"].attributes[attributeName].dataType;

            dv = DataValueFactory.BuildValue(t);
            switch (t)
            {
            case "StringType":
                ((StringValue)dv).value = (String)attributeValue;
                break;

            case "DoubleType":
                ((DoubleValue)dv).value = (Double)attributeValue;
                break;

            case "IntegerType":
                ((IntegerValue)dv).value = (Int32)attributeValue;
                break;

            case "BooleanType":
                ((BooleanValue)dv).value = (Boolean)attributeValue;
                break;

            case "LocationType":
                double[] xyz = (double[])attributeValue;
                ((LocationValue)dv).X      = xyz[0];
                ((LocationValue)dv).Y      = xyz[1];
                ((LocationValue)dv).Z      = xyz[2];
                ((LocationValue)dv).exists = true;

                break;

            case "VelocityType":
                double[] vxvyvz = (double[])attributeValue;
                ((LocationValue)dv).X = vxvyvz[0];
                ((LocationValue)dv).Y = vxvyvz[1];
                ((LocationValue)dv).Z = vxvyvz[2];
                break;

            default:

                break;
            }
            return(dv);
        }
Example #2
0
        static public SimulationEvent BuildEvent(ref SimulationModelInfo model, string eventType)
        {
            SimulationEvent e = new SimulationEvent();

            if (!model.eventModel.events.ContainsKey(eventType))
            {
                throw new Exception("Event type doesn't exist");
            }

            foreach (ParameterInfo pInfo in model.eventModel.events[eventType].parameters.Values)
            {
                e[pInfo.name] = DataValueFactory.BuildValue(pInfo.dataType);
            }
            e.eventType = eventType;

            return(e);
        }
Example #3
0
        static public SimulationObject BuildObject(ref SimulationModelInfo model, string objectType)
        {
            SimulationObject o = new SimulationObject();

            if (!model.objectModel.objects.ContainsKey(objectType))
            {
                throw new Exception("Object type doesn't exist");
            }

            foreach (AttributeInfo aInfo in model.objectModel.objects[objectType].attributes.Values)
            {
                o[aInfo.name] = DataValueFactory.BuildValue(aInfo.dataType);
            }
            o.objectType = objectType;

            return(o);
        }
        /// <summary>
        /// This method takes in a capabilities list, and a docked weapons list, and quantifies the weapons and
        /// combines those results with the capabilities list for a returned "CapabilitiesList", which the
        /// client displays to its user.
        /// </summary>
        /// <param name="atts"></param>
        private void AddCapabilitiesAndWeaponsList(ref AttributeCollectionValue atts)
        {
            List <string>            capabilities         = new List <string>();
            Dictionary <string, int> weaponsAndQuantities = new Dictionary <string, int>();
            string objectID           = ((StringValue)atts["ID"]).value;
            SimulationObjectProxy obj = objectProxies[objectID];
            CapabilityValue       cv;

            if (atts.attributes.ContainsKey("Capability"))
            {
                cv = atts["Capability"] as CapabilityValue;
                // atts.attributes.Remove("Capability");
            }
            else
            {
                cv = obj["Capability"].GetDataValue() as CapabilityValue;
            }
            foreach (CapabilityValue.Effect ef in ((CapabilityValue)cv).effects)
            {
                if (!capabilities.Contains(ef.name))
                {
                    capabilities.Add(ef.name);
                }
            }

            StringListValue       sl;
            SimulationObjectProxy wep;
            string className;

            if (atts.attributes.ContainsKey("DockedWeapons"))
            {
                sl = atts["DockedWeapons"] as StringListValue;
            }
            else
            {
                sl = obj["DockedWeapons"].GetDataValue() as StringListValue;
            }
            foreach (string weapon in sl.strings)
            {
                wep       = objectProxies[weapon];
                className = ((StringValue)wep["ClassName"].GetDataValue()).value;
                if (!weaponsAndQuantities.ContainsKey(className))
                {
                    weaponsAndQuantities.Add(className, 0);
                }
                weaponsAndQuantities[className]++;
            }

            List <string> CapabilitiesAndWeaponsList = new List <string>();

            foreach (string c in capabilities)
            {
                CapabilitiesAndWeaponsList.Add(c);
            }
            foreach (string w in weaponsAndQuantities.Keys)
            {
                CapabilitiesAndWeaponsList.Add(String.Format("{0} ({1}x)", w, weaponsAndQuantities[w]));
            }
            DataValue retDV = DataValueFactory.BuildValue("StringListType");

            ((StringListValue)retDV).strings = CapabilitiesAndWeaponsList;

            atts.attributes.Add("CapabilitiesList", retDV);
        }
Example #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="allObjectViews"></param>
        private void SenseAllObjects(ref Dictionary <string, Dictionary <string, AttributeCollectionValue> > allObjectsViews)
        {
            SimulationObjectProxy sensingProxy        = null;
            SimulationObjectProxy targetProxy         = null;
            Vec3D                    sensingLocation  = null;
            Vec3D                    targetsLocation  = null;
            LocationValue            senLocation      = null;
            LocationValue            tarLocation      = null;
            double                   distance         = 0.0;
            SensorArrayValue         sav              = null;
            DataValue                targetsAttribute = null;
            string                   ownerID          = null;
            string                   objectType       = null;
            DetectedAttributeValue   detectedAttribute;
            AttributeCollectionValue singleAttributeCollection = null;
            bool isSensed = false;

            // The dictionary is constantly created in this method //
            Dictionary <string, AttributeCollectionValue> singleObjectView;

            //AD to improve this later:
            // for each object in the visible ObjectDistances collection
            //    for each object after the current index
            //       check for the index object's view of the nested object
            //       check for the nested object's view of the index object
            //Possible hangup is the "All" emitter.



            int x = 0;

            //Each object senses each other object
            //foreach (string sensorObjectID in listOfObjectIDs)
            foreach (KeyValuePair <string, List <string> > networks in networkRosters)
            {
                if (!activeSensorNetworks[networks.Key])
                {
                    continue;
                }
                foreach (string sensorObjectID in networkObjects[networks.Key])
                {
                    sensingProxy = objectProxies[sensorObjectID];
                    objectType   = sensingProxy.GetObjectType();
                    senLocation  = sensingProxy["Location"].GetDataValue() as LocationValue;
                    if (senLocation.exists)
                    {
                        ownerID          = ((StringValue)sensingProxy["OwnerID"].GetDataValue()).value;
                        singleObjectView = new Dictionary <string, AttributeCollectionValue>();
                        x++;
                        //foreach (string targetObjectID in listOfObjectIDs)
                        foreach (List <string> objects in networkObjects.Values)
                        {
                            if (objects.Contains(sensorObjectID))
                            {
                                if (((EmitterValue)sensingProxy["Emitters"].GetDataValue()).emitters.ContainsKey("Invisible"))
                                //OR if it's the "master" object for a region?? -lisa
                                {
                                    continue;
                                }
                                string target = sensorObjectID;

                                singleAttributeCollection = new AttributeCollectionValue();
                                foreach (KeyValuePair <string, AttributeInfo> simModelAtt in simModel.objectModel.objects[objectType].attributes)
                                {
                                    if (!simModelAtt.Value.ownerObservable == true)
                                    {
                                        continue;
                                    }
                                    //if (!sensingProxy.GetKeys().Contains(simModelAtt.Key))
                                    //    continue;
                                    DataValue t = sensingProxy[simModelAtt.Key].GetDataValue();
                                    if (t.dataType == "CustomAttributesType")
                                    {
                                        Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
                                        t = new CustomAttributesValue();
                                        ((CustomAttributesValue)t).attributes = copiedDict;
                                    }
                                    detectedAttribute        = new DetectedAttributeValue();
                                    detectedAttribute.stdDev = 100;
                                    detectedAttribute.value  = DataValueFactory.BuildFromDataValue(t);
                                    AddAttributeToACV(ref singleAttributeCollection, simModelAtt.Key, detectedAttribute);
                                }//end foreach sensable attribute

                                if (!allObjectsViews.ContainsKey(sensorObjectID))
                                {
                                    allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
                                }
                                if (!objectViews.ContainsKey(sensorObjectID))
                                {
                                    objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
                                }
                                //update the global "allObjectViews".  The return from UpdateObject is the collection of attributes
                                //that have changed.  These attributes are stored in allObjectsViews and then sent out
                                //to users.
                                AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(target, singleAttributeCollection);

                                //if (changedAttributes != null && selectedRangeRingLevel != RangeRingLevels.DISABLED)
                                //{
                                //    CalculateRangeRings(ref changedAttributes, ref sensingProxy);
                                //}

                                if (changedAttributes != null)
                                {
                                    allObjectsViews[sensorObjectID].Add(target, changedAttributes);
                                }
                                else//this is so there is at least the empty entry for the detected object so
                                //you still know it is detected.
                                {
                                    if (!allObjectsViews[sensorObjectID].ContainsKey(target))
                                    {
                                        allObjectsViews[sensorObjectID].Add(target, new AttributeCollectionValue());
                                    }
                                }
                            }
                            else
                            {
                                foreach (string targetObjectID in objects)
                                {//sensing and target objects are not the same
                                    targetProxy = objectProxies[targetObjectID];
                                    tarLocation = targetProxy["Location"].GetDataValue() as LocationValue;
                                    if (tarLocation.exists)
                                    {
                                        EmitterValue emitters = targetProxy["Emitters"].GetDataValue() as EmitterValue;
                                        if (emitters.emitters.ContainsKey("All"))
                                        {
                                            //if an object has an all emitter, retrieve all attributes without sensing algorithm
                                            AttributeCollectionValue atts = new AttributeCollectionValue();
                                            if (singleObjectView.ContainsKey(targetObjectID))
                                            {
                                                atts = singleObjectView[targetObjectID];
                                            }
                                            SenseAllAttributes(ref atts, targetProxy);
                                            singleObjectView[targetObjectID] = atts;
                                            isSensed = true;

                                            if (!allObjectsViews.ContainsKey(sensorObjectID))
                                            {
                                                allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
                                            }
                                            if (!objectViews.ContainsKey(sensorObjectID))
                                            {
                                                objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
                                            }
                                            //update the global "allObjectViews".  The return from UpdateObject is the collection of attributes
                                            //that have changed.  These attributes are stored in allObjectsViews and then sent out
                                            //to users.
                                            AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);

                                            //if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
                                            //{//the only way to sense a "target" here is for FULL ring display
                                            //    CalculateRangeRings(ref changedAttributes, ref targetProxy);
                                            //}

                                            if (changedAttributes != null)
                                            {
                                                allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
                                            }
                                            else//this is so there is at least the empty entry for the detected object so
                                            //you still know it is detected.
                                            {
                                                if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
                                                {
                                                    allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
                                                }
                                            }
                                        }
                                        else if (emitters.emitters.ContainsKey("Invisible"))
                                        //or if object is "master" for moving region -lisa
                                        {
                                            continue;
                                        }
                                        else
                                        {//object does not have an all emitter, continue to check each emitter value
                                            AttributeCollectionValue atts = new AttributeCollectionValue();
                                            if (Omniscience)
                                            {
                                                if (singleObjectView.ContainsKey(targetObjectID))
                                                {
                                                    atts = singleObjectView[targetObjectID];
                                                }
                                                SenseAllAttributes(ref atts, targetProxy);
                                                singleObjectView[targetObjectID] = atts;
                                                isSensed = true;
                                                if (!allObjectsViews.ContainsKey(sensorObjectID))
                                                {
                                                    allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
                                                }
                                                if (!objectViews.ContainsKey(sensorObjectID))
                                                {
                                                    objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
                                                }
                                                //update the global "allObjectViews".  The return from UpdateObject is the collection of attributes
                                                //that have changed.  These attributes are stored in allObjectsViews and then sent out
                                                //to users.
                                                AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);

                                                //if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
                                                //{//the only way to sense a "target" here is for FULL ring display
                                                //    CalculateRangeRings(ref changedAttributes, ref targetProxy);
                                                //}

                                                if (changedAttributes != null)
                                                {
                                                    allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
                                                }
                                                else//this is so there is at least the empty entry for the detected object so
                                                //you still know it is detected.
                                                {
                                                    if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
                                                    {
                                                        allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
                                                    }
                                                }
                                                continue;
                                            }

                                            sensingLocation = new Vec3D(senLocation);
                                            targetsLocation = new Vec3D(tarLocation);
                                            isSensed        = false;
                                            distance        = sensingLocation.ScalerDistanceTo(targetsLocation);
                                            sav             = sensingProxy["Sensors"].GetDataValue() as SensorArrayValue;

                                            foreach (SensorValue sv in sav.sensors)
                                            {
                                                if (distance < sv.maxRange)
                                                {
                                                    //Find obstructions
                                                    List <SimulationObjectProxy> obstructions = FindObstructions(sensingLocation, targetsLocation);

                                                    foreach (KeyValuePair <string, List <ConeValue> > kvp in sv.ranges)
                                                    { //Key is the attribute being sensed, value is a list of cones
                                                        if (kvp.Key == "All")
                                                        {
                                                            atts = new AttributeCollectionValue();
                                                            if (singleObjectView.ContainsKey(targetObjectID))
                                                            {
                                                                atts = singleObjectView[targetObjectID];
                                                            }
                                                            SenseAllAttributes(ref atts, targetProxy);
                                                            singleObjectView[targetObjectID] = atts;
                                                            isSensed = true;
                                                        }
                                                        else //not an All sensor, so run detection algorithm
                                                        {//Added in main-line
                                                            if (!emitters.emitters.ContainsKey(kvp.Key))
                                                            {
                                                                continue;
                                                            }
                                                            //Custom attributes fix:
                                                            DataValue currentDataValue;
                                                            try
                                                            {
                                                                currentDataValue = targetProxy[kvp.Key].GetDataValue();
                                                            }
                                                            catch
                                                            {
                                                                currentDataValue = targetProxy["CustomAttributes"].GetDataValue();
                                                                currentDataValue = ((CustomAttributesValue)currentDataValue)[kvp.Key];
                                                                //will throw an error here if object doesn't contain custom atts, or
                                                                //if it doesnt contain the specified custom att.
                                                            }

                                                            bool isObstructed = false;
                                                            foreach (SimulationObjectProxy reg in obstructions)
                                                            {
                                                                foreach (string attributeBlocked in ((StringListValue)reg["BlocksSensorTypes"].GetDataValue()).strings)
                                                                {
                                                                    if (kvp.Key == attributeBlocked)
                                                                    {
                                                                        isObstructed = true;
                                                                    }
                                                                }
                                                            }
                                                            if (isObstructed)
                                                            {
                                                                detectedAttribute            = new DetectedAttributeValue();
                                                                detectedAttribute.value      = DataValueFactory.BuildValue(currentDataValue.dataType);
                                                                detectedAttribute.confidence = 0;
                                                                //continue;
                                                            }
                                                            else
                                                            {
                                                                targetsAttribute = DataValueFactory.BuildFromDataValue(currentDataValue);
                                                                //ev is emitters
                                                                Dictionary <string, double> emitterCollection = emitters.emitters[kvp.Key];

                                                                detectedAttribute = new DetectedAttributeValue();
                                                                detectedAttribute = ObjectMath.Detection(senLocation, tarLocation, targetsAttribute, kvp.Value, emitterCollection, obstructions, ref randomGenerator);
                                                            }
                                                            if (detectedAttribute != null)
                                                            {
                                                                singleAttributeCollection = new AttributeCollectionValue();
                                                                if (singleObjectView.ContainsKey(targetObjectID))
                                                                {
                                                                    singleAttributeCollection = singleObjectView[targetObjectID];
                                                                }
                                                                AddAttributeToACV(ref singleAttributeCollection, kvp.Key, detectedAttribute);
                                                                isSensed = true;
                                                            }
                                                        }
                                                    }//end foreach attribute in sensor

                                                    //if the object has any attributes sensed, fill in some other info for the object's view.
                                                    if (isSensed)
                                                    {
                                                        detectedAttribute        = new DetectedAttributeValue();
                                                        detectedAttribute.stdDev = 100;
                                                        detectedAttribute.value  = targetProxy["ID"].GetDataValue();
                                                        if (singleAttributeCollection == null)
                                                        {
                                                            singleAttributeCollection = new AttributeCollectionValue();
                                                        }
                                                        if (!singleObjectView.ContainsKey(targetObjectID))
                                                        {
                                                            singleObjectView.Add(targetObjectID, singleAttributeCollection);
                                                        }
                                                        singleAttributeCollection = singleObjectView[targetObjectID];
                                                        AddAttributeToACV(ref singleAttributeCollection, "ID", detectedAttribute);

                                                        detectedAttribute        = new DetectedAttributeValue();
                                                        detectedAttribute.stdDev = 100;
                                                        detectedAttribute.value  = targetProxy["OwnerID"].GetDataValue();
                                                        AddAttributeToACV(ref singleAttributeCollection, "OwnerID", detectedAttribute);
                                                    } //end if isSensed.
                                                }
                                            }         //end foreach sensor in sensor array

                                            if (singleObjectView.ContainsKey(targetObjectID))
                                            {
                                                AttributeCollectionValue attr = singleObjectView[targetObjectID];
                                                if (!allObjectsViews.ContainsKey(sensorObjectID))
                                                {
                                                    allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
                                                }
                                                if (!objectViews.ContainsKey(sensorObjectID))
                                                {
                                                    objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
                                                }

                                                if (attr.attributes.ContainsKey("CustomAttributes"))
                                                {
                                                    DataValue t    = ((DetectedAttributeValue)attr["CustomAttributes"]).value;
                                                    double    conf = ((DetectedAttributeValue)attr["CustomAttributes"]).confidence;
                                                    Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
                                                    t = new CustomAttributesValue();
                                                    ((CustomAttributesValue)t).attributes = copiedDict;
                                                    attr.attributes.Remove("CustomAttributes");
                                                    attr.attributes.Add("CustomAttributes", DataValueFactory.BuildDetectedValue(t, Convert.ToInt32(conf)));
                                                }
                                                //update the global "allObjectViews".  The return from UpdateObject is the collection of attributes
                                                //that have changed.  These attributes are stored in allObjectsViews and then sent out
                                                //to users.
                                                AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, attr);

                                                //if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
                                                //{//the only way to sense a "target" here is for FULL ring display
                                                //    CalculateRangeRings(ref changedAttributes, ref targetProxy);
                                                //}

                                                if (changedAttributes != null)
                                                {
                                                    allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
                                                }
                                                else//this is so there is at least the empty entry for the detected object so
                                                //you still know it is detected.
                                                {
                                                    if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
                                                    {
                                                        allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                if (objectViews.ContainsKey(sensorObjectID))
                                                {
                                                    if (objectViews[sensorObjectID].ContainsObject(targetObjectID))
                                                    {
                                                        objectViews[sensorObjectID].RemoveObject(targetObjectID);
                                                        //if you once knew of this object, and now don't, remove it from object's view.
                                                    }
                                                }
                                            }
                                        } //end emitter detection
                                    }     //end if target is visible
                                }
                            }
                        } //end foreach target object
                    }     //end if sensor is visible
                }         //end of foreach sensing object
            }             //end of Foreach sensor network
            if (x > 0)
            {
                //Console.Out.WriteLine("ViewPro: {0} objects were sensing at time {1}.", x, currentTick / 1000);
            }
        }
Example #6
0
        static void Main(string[] args)
        {
            Polygon2D poly = new Polygon2D();

            poly.AddVertex(new Vec2D(1, 1));
            poly.AddVertex(new Vec2D(4, 1));
            poly.AddVertex(new Vec2D(2.5, 3));
            poly.AddVertex(new Vec2D(4, 3));
            poly.AddVertex(new Vec2D(4, 4));
            poly.AddVertex(new Vec2D(2, 3.5));

            bool r;

            r = Polygon2D.IsPointInside(poly, new Vec2D(5, 3));                                                 //false
            r = Polygon2D.IsPointInside(poly, new Vec2D(2, 2));                                                 //true
            r = Polygon2D.IsPointInside(poly, new Vec2D(3.5, 3.5));                                             //true
            r = Polygon2D.IsPointInside(poly, new Vec2D(1, 3.5));                                               //false
            r = Polygon2D.IsPointInside(poly, new Vec2D(3, 2.5));                                               //false

            r = Polygon2D.DoLinesIntersect(new Vec2D(0, 2), new Vec2D(3, 0), new Vec2D(1, 1), new Vec2D(3, 3)); //true
            r = Polygon2D.DoLinesIntersect(new Vec2D(0, 2), new Vec2D(3, 0), new Vec2D(2, 1), new Vec2D(3, 3)); //false

            DataValue dv = DataValueFactory.BuildValue("CapabilityType");

            ((CapabilityValue)dv).effects.Add(new CapabilityValue.Effect("foo", 45, 10, .50));
            ((CapabilityValue)dv).effects.Add(new CapabilityValue.Effect("foo", 100, 5, .25));

            string s = DataValueFactory.XMLSerialize(dv);

            DataValue dv2 = DataValueFactory.XMLDeserialize(s);

            DataValue dv3 = DataValueFactory.BuildValue("VulnerabilityType");

            VulnerabilityValue.Transition t = new VulnerabilityValue.Transition("dead");
            t.conditions.Add(new VulnerabilityValue.TransitionCondition("foo", 50, 0, 0));
            t.conditions.Add(new VulnerabilityValue.TransitionCondition("bar", 20, 0, 0));

            ((VulnerabilityValue)dv3).transitions.Add(t);

            t = new VulnerabilityValue.Transition("hurt");
            t.conditions.Add(new VulnerabilityValue.TransitionCondition("foo", 25, 0, 0));
            ((VulnerabilityValue)dv3).transitions.Add(t);

            s = DataValueFactory.XMLSerialize(dv3);

            DataValue dv4 = DataValueFactory.XMLDeserialize(s);

            System.Console.WriteLine(s == DataValueFactory.XMLSerialize(dv4));

            DataValue dv5 = DataValueFactory.BuildValue("StateTableType");
            DataValue dv6 = DataValueFactory.BuildValue("AttributeCollectionType");

            ((StateTableValue)dv5).states["foo"] = DataValueFactory.BuildValue("DoubleType");
            ((AttributeCollectionValue)dv6).attributes["foo2"] = DataValueFactory.BuildValue("DoubleType");
            ((StateTableValue)dv5).states["bar"] = dv6;

            s = DataValueFactory.XMLSerialize(dv5);

            DataValue dv7 = DataValueFactory.XMLDeserialize(s);

            DataValue dv8 = DataValueFactory.BuildValue("StringListType");

            ((StringListValue)dv8).strings.Add("Foo");
            ((StringListValue)dv8).strings.Add("Bar");

            s = DataValueFactory.XMLSerialize(dv8);

            dv8 = DataValueFactory.XMLDeserialize(s);

            DataValue dv9 = DataValueFactory.BuildValue("PolygonType");

            ((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(0, 0));
            ((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(10.234, 34.097));
            ((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(10.234, 1.2));

            s = DataValueFactory.XMLSerialize(dv9);

            DataValue dv10 = DataValueFactory.XMLDeserialize(s);
        }