Implement memory loading for BG NSphere

Author: awulkiew

solution/GraphicalDebugging/ExpressionDrawer.cs

@@ -289,13 +289,20 @@ public void Draw(Geometry.Box box, Graphics graphics, Settings settings, Geometr
                 }
                 else // Radian, Degree
                 {
+                    
                     if (rx == 0 || ry == 0)
                         drawer.DrawPeriodicPoint(cs, Center, box, traits.Unit, settings.showDots);
                     else
                     {
                         Drawer.PeriodicDrawableNSphere pd = new Drawer.PeriodicDrawableNSphere(cs, this, traits.Unit);
                         Geometry.Interval interval = RelativeEnvelopeLon(this, traits.Unit);
-                        drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, true, false, settings.showDots);
+                        try
+                        {
+                            drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, true, false, settings.showDots);
+                        } catch (Exception e)
+                        {
+                            int a = 10;
+                        }
                     }
                 }
             }

solution/GraphicalDebugging/ExpressionLoader.cs

@@ -764,7 +764,20 @@ public override ExpressionDrawer.IDrawable DrawableFromMemory(MemoryReader.Conve
         }
 
         abstract class NSphereLoader : GeometryLoader<ExpressionDrawer.NSphere>
-        { }
+        {
+            public override ExpressionDrawer.IDrawable DrawableFromMemory(MemoryReader.Converter<double> converter,
+                                                                          double[] values, int offset)
+            {
+                int valCount = converter.ValueCount();
+                if (valCount == 3)
+                {
+                    var c = new ExpressionDrawer.Point(values[offset], values[offset + 1]);
+                    var r = values[offset + 2];
+                    return new ExpressionDrawer.NSphere(c, r);
+                }
+                return null;
+            }
+        }
 
         abstract class RangeLoader<ResultType> : GeometryLoader<ResultType>
             where ResultType : ExpressionDrawer.IDrawable
@@ -1158,22 +1171,35 @@ public Loader Create(Loaders loaders, Debugger debugger, string name, string typ
                         return null;
 
                     string m_center = name + ".m_center";
+                    string m_radius = name + ".m_radius";
 
                     string pointType = tparams[0];
                     PointLoader pointLoader = loaders.FindByType(ExpressionLoader.Kind.Point,
                                                                  m_center,
                                                                  pointType) as PointLoader;
-                    if (pointLoader == null)
-                        return null;
 
-                    return new BGNSphere(pointLoader, pointType);
+                    string radiusType = tparams[1];
+                    
+                    return pointLoader != null
+                        && debugger.GetTypeSizeof(type, out int sizeOf)
+                        && debugger.GetAddressOffset(name, m_center, out long centerDiff)
+                        && debugger.GetAddressOffset(name, m_radius, out long radiusDiff)
+                        && debugger.GetCppSizeof(radiusType, out int radiusSize)
+                        && !Debugger.IsInvalidOffset(sizeOf, centerDiff, radiusDiff)
+                         ? new BGNSphere(pointLoader, pointType, radiusType, radiusSize, sizeOf, centerDiff, radiusDiff)
+                         : null;
                 }
             }
 
-            private BGNSphere(PointLoader pointLoader, string pointType)
+            private BGNSphere(PointLoader pointLoader, string pointType, string radiusType, int radiusSize, int sizeOf, long centerDiff, long radiusDiff)
             {
                 this.pointLoader = pointLoader;
                 this.pointType = pointType;
+                this.radiusType = radiusType;
+                this.radiusSize = radiusSize;
+                this.sizeOf = sizeOf;
+                this.centerDiff = centerDiff;
+                this.radiusDiff = radiusDiff;
             }
 
             public override Geometry.Traits GetTraits(MemoryReader mreader, Debugger debugger,
@@ -1189,18 +1215,42 @@ public override ExpressionDrawer.IDrawable Load(MemoryReader mreader, Debugger d
                 string m_center = name + ".m_center";
                 string m_radius = name + ".m_radius";
 
-                Geometry.Point center = pointLoader.LoadPoint(mreader, debugger,
-                                                              m_center, pointType);
-
+                Geometry.Point center = pointLoader.LoadPoint(mreader, debugger, m_center, pointType);
                 bool ok = debugger.TryLoadDouble(m_radius, out double radius);
 
                 return Util.IsOk(center, ok)
                      ? new ExpressionDrawer.NSphere(center, radius)
                      : null;
             }
 
+            public override MemoryReader.Converter<double> GetMemoryConverter(MemoryReader mreader,
+                                                                              Debugger debugger, // TODO - remove
+                                                                              string name, string type)
+            {
+                // NOTE: In case it was created by derived class and these members set to invalid values
+                if (sizeOf <= 0
+                 || Debugger.IsInvalidOffset(sizeOf, centerDiff, radiusDiff))
+                    return null;
+
+                string m_center = name + ".m_center";
+                MemoryReader.Converter<double> pointConverter = pointLoader.GetMemoryConverter(mreader, debugger, m_center, pointType);
+                if (pointConverter == null)
+                    return null;
+
+                MemoryReader.Converter<double> radiusConverter = mreader.GetNumericConverter(radiusType, radiusSize);
+
+                return new MemoryReader.StructConverter<double>(sizeOf,
+                            new MemoryReader.Member<double>(pointConverter, (int)centerDiff),
+                            new MemoryReader.Member<double>(radiusConverter, (int)radiusDiff));
+            }
+
             private readonly PointLoader pointLoader;
             private readonly string pointType;
+            private readonly string radiusType;
+            private readonly int radiusSize;
+            private readonly long centerDiff;
+            private readonly long radiusDiff;
+            private readonly int sizeOf;
         }
 
         abstract class PointRange<ResultType> : RangeLoader<ResultType>