cpp.xml

<?xml version="1.0" encoding="utf-8"?>
<GraphicalDebugging>

  <!--
  Supported elements:
    - Container
    - Point
    - Box
    - Linestring
    - Ring (polygon without holes)
    - Polygon (polygon with holes)
    - MultiPoint
    - MultiLinestring
    - MultiPolygon
    - MultiGeometry
  
  Arguments of all elements:
    - Type: type pattern, e.g.: "MyNamespace::MyId&lt;*&gt;"
    - Id: qualified identifier of a type, e.g. "MyNamespace::MyId"
  
    Both Type and Id is defined only as an example below. Only one of these
    definitions is needed. If both are defined the Type has the priority over
    Id.
  
  Arguments of Point element:
    - CoordinateSystem:
      - "Cartesian"
      - "Spherical"
      - "Geographic"
      - "Complex"
    - Unit:
      - "Radian"
      - "Degree"
  
    The CoordinateSystem and Unit can be set in Point element and are
    "inherited" by all other geometries using this Point type.
    They can also be set in Box element since it is possible to define
    it using coordinates instead of points.
  
    By default the CoordinateSystem is Cartesian and Unit is None. The default
    Unit for Spherical and Geographic coordinate systems is Degree.
  -->

  <!--
  struct tagPOINT {
    long x;
    long y;
  };
  -->
  <Point Type="tagPOINT" Id="tagPOINT">
  <!--Point Type="tagPOINT"-->
  <!--Point Id="tagPOINT"-->
    <Coordinates>
      <X>x</X>
      <Y>y</Y>
    </Coordinates>
  </Point>

  <!--
  namespace boost { namespace qvm {
  template <class T,int Dim>
  struct vec
  {
      T a[Dim];
  };
  }}
  -->
  <Point Type="boost::qvm::vec&lt;*&gt;" Id="boost::qvm::vec">
    <Coordinates>
      <X>a[0]</X>
      <Y>a[1]</Y>
    </Coordinates>
  </Point>

  <!--
  struct MyPoint
  {
      double x, y;
  };
  -->
  <Point Type="MyPoint" Id="MyPoint" CoordinateSystem="Cartesian" Unit="None">
    <Coordinates>
      <X>x</X>
      <Y>y</Y>
    </Coordinates>
  </Point>

  <!--
  struct MyBox
  {
      MyPoint mi, ma;
  };
  -->
  <Box Type="MyBox" Id="MyBox">
    <Points>
      <Min>mi</Min>
      <Max>ma</Max>
    </Points>
  </Box>

  <!--
  struct MyBox1
  {
      double left, bottom, right, top;
  };
  -->
  <Box Type="MyBox1" Id="MyBox1" CoordinateSystem="Cartesian" Unit="None">
    <Coordinates>
      <MinX>left</MinX> <!-- or <Left> -->
      <MinY>bottom</MinY> <!-- or <Bottom> -->
      <MaxX>right</MaxX> <!-- or <Right> -->
      <MaxY>top</MaxY> <!-- or <Top> -->
    </Coordinates>
  </Box>

  <!--
  struct MyBox2
  {
      double left, bottom, width, height;
  };
  -->
  <Box Type="MyBox2" Id="MyBox2" CoordinateSystem="Cartesian" Unit="None">
    <CoordinatesDimensions>
      <MinX>left</MinX> <!-- or <Left> or <MaxX> or <Right> or <CenterX>-->
      <MinY>bottom</MinY> <!-- or <Bottom> or <MaxY> or <Top> or <CenterY> -->
      <Width>width</Width>
      <Height>height</Height>
    </CoordinatesDimensions>
  </Box>

  <!--
  struct MySegment
  {
      struct { double x, y; } first;
      struct { double x, y; } second;
  };
  -->  
  <Segment Id="MySegment">
    <Coordinates>
      <FirstX>first.x</FirstX>
      <FirstY>first.y</FirstY>
      <SecondX>second.x</SecondX>
      <SecondY>second.y</SecondY>
    </Coordinates>
  </Segment>

  <!--
  struct MyRay
  {
      struct { double x, y; } origin;
      struct { double x, y; } direction;
  };
  -->
  <Ray Id="MyRay">
    <Coordinates>
      <OriginX>origin.x</OriginX>
      <OriginY>origin.y</OriginY>
      <DirectionX>direction.x</DirectionX>
      <DirectionY>direction.y</DirectionY>
    </Coordinates>
  </Ray>

  <!--
  struct MyLine
  {
      struct { double x, y; } first;
      struct { double x, y; } second;
  };
  -->
  <Line Id="MyLine">
    <Coordinates>
      <FirstX>first.x</FirstX>
      <FirstY>first.y</FirstY>
      <SecondX>second.x</SecondX>
      <SecondY>second.y</SecondY>
    </Coordinates>
  </Line>

  <!--
  struct MyLinestring
  {
      std::vector<MyPoint> points;
  };
  -->
  <Linestring Type="MyLinestring" Id="MyLinestring">
    <Points>
      <Container>
        <Name>points</Name>
      </Container>
    </Points>
  </Linestring>

  <!--
  template <typename Point>
  struct MyLinestring2 : std::vector<Point>
  { };
  -->
  <Linestring Type="MyLinestring2&lt;*&gt;" Id="MyLinestring2">
    <Points>
      <Container>
        <Name>(std::vector&lt;$T0,std::allocator&lt;$T0&gt; &gt;&amp;)(*this)</Name>
      </Container>
    </Points>
  </Linestring>

  <!--
  struct MyLinestring3
  {
      MyPoint * begin;
      MyPoint * end;
  };
  -->
  <Linestring Type="MyLinestring3" Id="MyLinestring3">
    <Points>
      <Array>
        <Pointer>begin</Pointer>
        <Size>end - begin</Size>
      </Array>
    </Points>
  </Linestring>

  <!--
  template <typename Point>
  struct MyLinestring4 : std::vector<Point>
  { };
  -->
  <Linestring Type="MyLinestring4&lt;*&gt;" Id="MyLinestring4">
    <Points>
      <Array>
        <Pointer>_Mypair._Myval2._Myfirst</Pointer>
        <Size>_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst</Size>
      </Array>
    </Points>
  </Linestring>

  <!--
  template <typename Point>
  struct MyLinestring5 : std::list<Point>
  { };
  -->
  <Linestring Type="MyLinestring5&lt;*&gt;" Id="MyLinestring5">
    <Points>
      <LinkedList>
        <Size>_Mypair._Myval2._Mysize</Size>
        <HeadPointer>_Mypair._Myval2._Myhead-&gt;_Next</HeadPointer>
        <NextPointer>_Next</NextPointer>
        <Value>_Myval</Value>
      </LinkedList>
    </Points>
  </Linestring>

  <!--
  struct MyRing : std::vector<MyPoint>
  { };
  -->
  <Ring Type="MyRing" Id="MyRing">
    <Points>
      <Container>
        <Name>(std::vector&lt;MyPoint,std::allocator&lt;MyPoint&gt; &gt;&amp;)(*this)</Name>
      </Container>
    </Points>
  </Ring>

  <!--
  struct MyPolygon
  {
      MyRing outer;
      std::vector<MyRing> inners;
  };
  -->
  <Polygon Type="MyPolygon" Id="MyPolygon">
    <ExteriorRing>
      <Name>outer</Name>
    </ExteriorRing>
    <InteriorRings>
      <Container>
        <Name>inners</Name>
      </Container>
      <!--Offset>0</Offset-->
    </InteriorRings>
  </Polygon>

  <!--
  struct MyPolygon2 : std::vector<MyRing>
  { };
  -->
  <Polygon Type="MyPolygon2" Id="MyPolygon2">
    <ExteriorRing>
      <Name>(*_Mypair._Myval2._Myfirst)</Name>
    </ExteriorRing>
    <InteriorRings>
      <Container>
        <Name>(std::vector&lt;MyRing,std::allocator&lt;MyRing&gt; &gt;&amp;)(*this)</Name>
      </Container>
      <Offset>1</Offset>
    </InteriorRings>
  </Polygon>

  <!--
  struct MyMultiPoint
  {
      std::vector<MyPoint> points;
  };
  -->
  <MultiPoint Type="MyMultiPoint" Id="MyMultiPoint">
    <Points>
      <Container>
        <Name>points</Name>
      </Container>
    </Points>
  </MultiPoint>

  <!--
  struct MyMultiLinestring
  {
      std::vector<MyLinestring> linestrings;
  };
  -->
  <MultiLinestring Type="MyMultiLinestring" Id="MyMultiLinestring">
    <Linestrings>
      <Container>
        <Name>linestrings</Name>
      </Container>
    </Linestrings>
  </MultiLinestring>

  <!--
  struct MyMultiPolygon
  {
      std::vector<MyPolygon> polygons;
  };
  -->
  <MultiPolygon Type="MyMultiPolygon" Id="MyMultiPolygon">
    <Polygons>
      <Container>
        <Name>polygons</Name>
      </Container>
    </Polygons>
  </MultiPolygon>

  <!--
  struct MyMultiRing
  {
      std::vector<MyRing> rings;
  };
  -->
  <MultiGeometry Type="MyMultiRing" Id="MyMultiRing">
    <Geometries>
      <Container>
        <Name>rings</Name>
      </Container>
    </Geometries>
  </MultiGeometry>
  
  <!--
  template <typename T>
  struct MyVector : std::vector<T>
  { };
  -->
  <Container Type="MyVector&lt;*&gt;" Id="MyVector">
    <Array>
      <Pointer>_Mypair._Myval2._Myfirst</Pointer>
      <Size>_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst</Size>
    </Array>
  </Container>

  <!--
  template <typename T>
  struct MyList : std::list<T>
  { };
  -->
  <Container Type="MyList&lt;*&gt;" Id="MyList">
    <LinkedList>
      <Size>_Mypair._Myval2._Mysize</Size>
      <HeadPointer>_Mypair._Myval2._Myhead-&gt;_Next</HeadPointer>
      <NextPointer>_Next</NextPointer>
      <Value>_Myval</Value>
    </LinkedList>
  </Container>

</GraphicalDebugging>