// Overridden form IParser
        public Workbench ReadFromStream(IION ion, Stream stream)
        {
            try {
                using (var reader = new BinaryReader(stream)) {
                    var v = reader.ReadInt32();

                    if (version != v)
                    {
                        throw new IOException("Cannot read workbench from stream: expected version " + version + " received " + v);
                    }

                    // Read the number of manifold that were stored
                    var len = reader.ReadInt32();

                    var ret = new Workbench(ion);

                    for (int i = 0; i < len; i++)
                    {
                        var manifold = ManifoldParser.ReadManifold(ion, reader);
                        if (manifold != null)
                        {
                            try {
                                //ret.Add(manifold);
                                //ret.Add(manifold);
                            } catch (Exception e) {
                                Log.E(this, "Failed to read manifold", e);
                            }
                        }
                    }

                    return(ret);
                }
            } catch (Exception e) {
                Log.E(this, "Failed to read workbench from stream", e);
                return(null);
            }
        }
        public Analyzer ReadFromStream(IION ion, Stream stream)
        {
            var buffer = new byte[1024];
            var len    = stream.Read(buffer, 0, buffer.Length);

            var b = new byte[len];

            Array.Copy(buffer, b, len);
            var ms = new MemoryStream(b);

            using (var reader = new BinaryReader(ms)) {
                Analyzer ret = null;

                // Read the version of the parser
                var v = reader.ReadInt32();
                if (version != v)
                {
                    //throw new Exception("Cannot read analyzer from stream: expected version " + this.version + " received " + v);
                }
                // Read the number of sensor per side
                var sensorsPerSide = reader.ReadInt32();
                // Create the analyzer that we are inflating
                ret = new Analyzer(ion, sensorsPerSide);
                for (int i = 0; i < sensorsPerSide * 2; i++)
                {
                    var sensor = SensorParser.ReadSensor(ion, reader);
                    if (sensor != null)
                    {
                        ret.PutSensor(i, sensor, true);
                    }
                }

                // Read the low side manifold
                if (reader.ReadBoolean())
                {
                    var checkSensor = ManifoldParser.ReadManifold(ion, reader);
                    ret.SetManifold(Analyzer.ESide.Low, checkSensor);

                    ret.lowSideSensor.SetLinkedSensor(checkSensor.linkedSensor);
                    foreach (var sp in checkSensor.sensorProperties)
                    {
                        ret.lowSideSensor.AddSensorProperty(sp);
                    }
                }

                // Read the high side manifold
                if (reader.ReadBoolean())
                {
                    var checkSensor = ManifoldParser.ReadManifold(ion, reader);
                    ret.SetManifold(Analyzer.ESide.High, checkSensor);

                    ret.highSideSensor.SetLinkedSensor(checkSensor.linkedSensor);
                    foreach (var sp in checkSensor.sensorProperties)
                    {
                        ret.highSideSensor.AddSensorProperty(sp);
                    }
                }

                return(ret);
            }
        }