OpenMetaverse.Messages.Linden.ViewerStatsMessage.Serialize C# (CSharp) Method

Serialize() public method

Serialize the object
public Serialize ( ) : OSDMap
return OSDMap
        public OSDMap Serialize()
        {
            OSDMap map = new OSDMap(5);
            map["session_id"] = OSD.FromUUID(SessionID);

            OSDMap agentMap = new OSDMap(11);
            agentMap["agents_in_view"] = OSD.FromInteger(AgentsInView);
            agentMap["fps"] = OSD.FromReal(AgentFPS);
            agentMap["language"] = OSD.FromString(AgentLanguage);
            agentMap["mem_use"] = OSD.FromReal(AgentMemoryUsed);
            agentMap["meters_traveled"] = OSD.FromReal(MetersTraveled);
            agentMap["ping"] = OSD.FromReal(AgentPing);
            agentMap["regions_visited"] = OSD.FromInteger(RegionsVisited);
            agentMap["run_time"] = OSD.FromReal(AgentRuntime);
            agentMap["sim_fps"] = OSD.FromReal(SimulatorFPS);
            agentMap["start_time"] = OSD.FromUInteger(Utils.DateTimeToUnixTime(AgentStartTime));
            agentMap["version"] = OSD.FromString(AgentVersion);
            map["agent"] = agentMap;


            OSDMap downloadsMap = new OSDMap(3); // downloads
            downloadsMap["object_kbytes"] = OSD.FromReal(object_kbytes);
            downloadsMap["texture_kbytes"] = OSD.FromReal(texture_kbytes);
            downloadsMap["world_kbytes"] = OSD.FromReal(world_kbytes);
            map["downloads"] = downloadsMap;

            OSDMap miscMap = new OSDMap(2);
            miscMap["Version"] = OSD.FromReal(MiscVersion);
            miscMap["Vertex Buffers Enabled"] = OSD.FromBoolean(VertexBuffersEnabled);
            map["misc"] = miscMap;

            OSDMap statsMap = new OSDMap(2);

            OSDMap failuresMap = new OSDMap(6);
            failuresMap["dropped"] = OSD.FromInteger(StatsDropped);
            failuresMap["failed_resends"] = OSD.FromInteger(StatsFailedResends);
            failuresMap["invalid"] = OSD.FromInteger(FailuresInvalid);
            failuresMap["off_circuit"] = OSD.FromInteger(FailuresOffCircuit);
            failuresMap["resent"] = OSD.FromInteger(FailuresResent);
            failuresMap["send_packet"] = OSD.FromInteger(FailuresSendPacket);
            statsMap["failures"] = failuresMap;

            OSDMap statsMiscMap = new OSDMap(3);
            statsMiscMap["int_1"] = OSD.FromInteger(MiscInt1);
            statsMiscMap["int_2"] = OSD.FromInteger(MiscInt2);
            statsMiscMap["string_1"] = OSD.FromString(MiscString1);
            statsMap["misc"] = statsMiscMap;

            OSDMap netMap = new OSDMap(3);

            // in
            OSDMap netInMap = new OSDMap(4);
            netInMap["compressed_packets"] = OSD.FromInteger(InCompressedPackets);
            netInMap["kbytes"] = OSD.FromReal(InKbytes);
            netInMap["packets"] = OSD.FromReal(InPackets);
            netInMap["savings"] = OSD.FromReal(InSavings);
            netMap["in"] = netInMap;
            // out
            OSDMap netOutMap = new OSDMap(4);
            netOutMap["compressed_packets"] = OSD.FromInteger(OutCompressedPackets);
            netOutMap["kbytes"] = OSD.FromReal(OutKbytes);
            netOutMap["packets"] = OSD.FromReal(OutPackets);
            netOutMap["savings"] = OSD.FromReal(OutSavings);
            netMap["out"] = netOutMap;

            statsMap["net"] = netMap;

            //system
            OSDMap systemStatsMap = new OSDMap(7);
            systemStatsMap["cpu"] = OSD.FromString(SystemCPU);
            systemStatsMap["gpu"] = OSD.FromString(SystemGPU);
            systemStatsMap["gpu_class"] = OSD.FromInteger(SystemGPUClass);
            systemStatsMap["gpu_vendor"] = OSD.FromString(SystemGPUVendor);
            systemStatsMap["gpu_version"] = OSD.FromString(SystemGPUVersion);
            systemStatsMap["os"] = OSD.FromString(SystemOS);
            systemStatsMap["ram"] = OSD.FromInteger(SystemInstalledRam);
            map["system"] = systemStatsMap;

            map["stats"] = statsMap;
            return map;
        }

Usage Example

        public void ViewerStatsMessage()
        {
            ViewerStatsMessage s = new ViewerStatsMessage();

            s.AgentFPS = 45.5f;
            s.AgentsInView = 1;
            s.SystemCPU = "Intel 80286";
            s.StatsDropped = 2;
            s.StatsFailedResends = 3;
            s.SystemGPU = "Vesa VGA+";
            s.SystemGPUClass = 4;
            s.SystemGPUVendor = "China";
            s.SystemGPUVersion = String.Empty;
            s.InCompressedPackets = 5000;
            s.InKbytes = 6000;
            s.InPackets = 22000;
            s.InSavings = 19;
            s.MiscInt1 = 5;
            s.MiscInt2 = 6;
            s.FailuresInvalid = 20;
            s.AgentLanguage = "en";
            s.AgentMemoryUsed = 12878728;
            s.MetersTraveled = 9999123;
            s.object_kbytes = 70001;
            s.FailuresOffCircuit = 201;
            s.SystemOS = "Palm OS 3.1";
            s.OutCompressedPackets = 8000;
            s.OutKbytes = 9000999;
            s.OutPackets = 21000210;
            s.OutSavings = 181;
            s.AgentPing = 135579;
            s.SystemInstalledRam = 4000000;
            s.RegionsVisited = 4579;
            s.FailuresResent = 9;
            s.AgentRuntime = 360023;
            s.FailuresSendPacket = 565;
            s.SessionID = UUID.Random();
            s.SimulatorFPS = 454;
            s.AgentStartTime = new DateTime(1973, 1, 16, 5, 23, 33);
            s.MiscString1 = "Unused String";
            s.texture_kbytes = 9367498382;
            s.AgentVersion = "1";
            s.MiscVersion = 1;
            s.VertexBuffersEnabled = true;
            s.world_kbytes = 232344439;

            OSDMap map = s.Serialize();
            ViewerStatsMessage t = new ViewerStatsMessage();
            t.Deserialize(map);

            Assert.AreEqual(s.AgentFPS, t.AgentFPS);
            Assert.AreEqual(s.AgentsInView, t.AgentsInView);
            Assert.AreEqual(s.SystemCPU, t.SystemCPU);
            Assert.AreEqual(s.StatsDropped, t.StatsDropped);
            Assert.AreEqual(s.StatsFailedResends, t.StatsFailedResends);
            Assert.AreEqual(s.SystemGPU, t.SystemGPU);
            Assert.AreEqual(s.SystemGPUClass, t.SystemGPUClass);
            Assert.AreEqual(s.SystemGPUVendor, t.SystemGPUVendor);
            Assert.AreEqual(s.SystemGPUVersion, t.SystemGPUVersion);
            Assert.AreEqual(s.InCompressedPackets, t.InCompressedPackets);
            Assert.AreEqual(s.InKbytes, t.InKbytes);
            Assert.AreEqual(s.InPackets, t.InPackets);
            Assert.AreEqual(s.InSavings, t.InSavings);
            Assert.AreEqual(s.MiscInt1, t.MiscInt1);
            Assert.AreEqual(s.MiscInt2, t.MiscInt2);
            Assert.AreEqual(s.FailuresInvalid, t.FailuresInvalid);
            Assert.AreEqual(s.AgentLanguage, t.AgentLanguage);
            Assert.AreEqual(s.AgentMemoryUsed, t.AgentMemoryUsed);
            Assert.AreEqual(s.MetersTraveled, t.MetersTraveled);
            Assert.AreEqual(s.object_kbytes, t.object_kbytes);
            Assert.AreEqual(s.FailuresOffCircuit, t.FailuresOffCircuit);
            Assert.AreEqual(s.SystemOS, t.SystemOS);
            Assert.AreEqual(s.OutCompressedPackets, t.OutCompressedPackets);
            Assert.AreEqual(s.OutKbytes, t.OutKbytes);
            Assert.AreEqual(s.OutPackets, t.OutPackets);
            Assert.AreEqual(s.OutSavings, t.OutSavings);
            Assert.AreEqual(s.AgentPing, t.AgentPing);
            Assert.AreEqual(s.SystemInstalledRam, t.SystemInstalledRam);
            Assert.AreEqual(s.RegionsVisited, t.RegionsVisited);
            Assert.AreEqual(s.FailuresResent, t.FailuresResent);
            Assert.AreEqual(s.AgentRuntime, t.AgentRuntime);
            Assert.AreEqual(s.FailuresSendPacket, t.FailuresSendPacket);
            Assert.AreEqual(s.SessionID, t.SessionID);
            Assert.AreEqual(s.SimulatorFPS, t.SimulatorFPS);
            Assert.AreEqual(s.AgentStartTime, t.AgentStartTime);
            Assert.AreEqual(s.MiscString1, t.MiscString1);
            Assert.AreEqual(s.texture_kbytes, t.texture_kbytes);
            Assert.AreEqual(s.AgentVersion, t.AgentVersion);
            Assert.AreEqual(s.MiscVersion, t.MiscVersion);
            Assert.AreEqual(s.VertexBuffersEnabled, t.VertexBuffersEnabled);
            Assert.AreEqual(s.world_kbytes, t.world_kbytes);
        }
ViewerStatsMessage