PolyPolylineData.h

namespace Larson
{
        class PolyPolylineData
        {
        public:
                PolyPolylineData(int nNewPolys = 0)
                { 
                        if (nNewPolys)
                        {
                                ppPts = new DPoint*[nNewPolys]();
                                counts = new long[nNewPolys]();
                        }
                        else
                        {
                                ppPts = NULL;
                                counts = NULL;
                        }
                        nPolys = nNewPolys;
                };
                ~PolyPolylineData()
                {
                        for (int n = 0; n < nPolys; n++)
                        {
                                if (ppPts[n])
                                        delete[] ppPts[n];
                        }
                        if (ppPts)
                                delete[] ppPts;
                        if (counts)
                                delete[] counts;
                };

                DPoint** ppPts;         // array of polyline pointers
                long* counts;           // number of points in each polyline
                long nPolys;            // number of polyline
                void operator=( const PolyPolylineData& a )
                {
                        ppPts  = new DPoint*[a.nPolys]();
                        counts = new long[a.nPolys]();

                        for (int n = 0; n < nPolys; n++)
                        {
                                counts[n-1] = a.counts[n-1];
                                ppPts[n-1] = new DPoint[a.counts[n-1]];
                                
                                for (int i = 0; i < a.counts[n-1]; i++)
                                        a.ppPts[n-1][i] = a.ppPts[n-1][i];
                        }
                }

                long AddSubPoly(DPoint* pts, long nPts)
                {
                        // new array of polyline pointers and counts
                        DPoint** newPPts = new DPoint*[nPolys+1];
                        long* newCounts = new long[nPolys+1];

                        // copy old to new
                        long i;
                        for (i = 0; i < nPolys; i++)
                        {
                                newPPts[i] = ppPts[i];
                                newCounts[i] = counts[i];
                        }
                        // delete the old
                        delete[] ppPts;
                        delete[] counts;

                        //add subpath points
                        ppPts = newPPts;
                        counts = newCounts;
                        
                        ppPts[i] = new DPoint[nPts];
                        for (long j = 0; j < nPts; j++)
                                ppPts[i][j] = pts[j];
                        counts[i] = nPts;

                        nPolys++;

                        return nPolys;
                }

                long AddPts(long subPoly, DPoint* pts, long nPts)
                {
                        if (subPoly < 0 || subPoly > nPolys)
                                return 0;

                        // allocate new subpath points array
                        DPoint* newPts = NULL;
                        try { newPts = new DPoint[counts[subPoly-1] + nPts]; }
                        catch(...){ return 0; }

                        // copy old points to new array
                        long i = 0;
                        for (; i < counts[subPoly-1]; i++)
                                newPts[i] = ppPts[subPoly-1][i];
                        // delete old points
                        delete[] ppPts[subPoly-1];

                        // add points to new subpath points array
                        ppPts[subPoly-1] = newPts;
                
                        for (int j = 0; j < nPts; j++)
                                newPts[i++] = pts[j];
                        counts[subPoly-1] += nPts;
                        
                        // return new subpath number of points
                        return counts[subPoly-1];
                }
        };
};