@q pntrvctr.web @>

@q * Copyright and License.@>

@q This file is part of GNU 3DLDF, a package for three-dimensional drawing. @>
@q Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, @>
@q 2011, 2012, 2013 The Free Software Foundation  @>

@q GNU 3DLDF is free software; you can redistribute it and/or modify @>
@q it under the terms of the GNU General Public License as published by @>
@q the Free Software Foundation; either version 3 of the License, or @>
@q (at your option) any later version. @>

@q GNU 3DLDF is distributed in the hope that it will be useful, @>
@q but WITHOUT ANY WARRANTY; without even the implied warranty of @>
@q MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the @>
@q GNU General Public License for more details. @>

@q You should have received a copy of the GNU General Public License @>
@q along with GNU 3DLDF; if not, write to the Free Software @>
@q Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA @>

@q GNU 3DLDF is a GNU package.  @>
@q It is part of the GNU Project of the  @>
@q Free Software Foundation @>
@q and is published under the GNU General Public License. @>
@q See the website http://www.gnu.org @>
@q for more information.   @>
@q GNU 3DLDF is available for downloading from @>
@q http://www.gnu.org/software/3dldf/LDF.html. @>

@q (``@@'' stands for a single at-sign in the following paragraph.) @>

@q Please send bug reports to Laurence.Finston@@gmx.de @>
@q The mailing list help-3dldf@@gnu.org is available for people to @>
@q ask other users for help.  @>
@q The mailing list info-3dldf@@gnu.org is for sending @>
@q announcements to users. To subscribe to these mailing lists, send an @>
@q email with ``subscribe <email-address>'' as the subject.  @>

@q The author can be contacted at: @>

@q Laurence D. Finston                 @> 
@q c/o Free Software Foundation, Inc.  @>
@q 51 Franklin St, Fifth Floor         @> 
@q Boston, MA  02110-1301              @>
@q USA                                 @>

@q Laurence.Finston@@gmx.de (@@ stands for a single ``at'' sign.)@>


@q * (0) |struct Pointer_Vector|.@>
@** {\bf struct Pointer\_Vector}\quad ({\tt pntrvctr\PERIOD web}).\hfil

\LOG
\initials{LDF 2005.11.12.}
Created this file.  It contains code for |struct Pointer_Vector| and its functions, 
which I've removed from \filename{pspglb.web}.  The use of |Scanner_Type| objects 
in functions caused compilation to fail on a user's system using GCC 3.4.3.
\ENDLOG

\immediate\write\functexifile{File:  pntrvctr.web^^J}

@q * (1) Include files.@>
@* Include files.

@<Include files@>=
#include "loader.h++"
#include "pspglb.h++"
#include "io.h++"

@q * (1) Template |struct Pointer_Vector|.@>
@*1 Template {\bf struct Pointer\_Vector}.  

The template parameter for a |Pointer_Vector| must be a class that 
defines a member function |show(string)|.
\initials{LDF 2004.08.25.}

\LOG
\initials{LDF 2004.08.25.}
Added this |struct| definition.

\initials{LDF 2005.02.28.}
Added the optional template parameter |class D| 
with default |class C|.
\ENDLOG 

@<Utility classes@>=

template<class C, class D>
struct
Pointer_Vector
{
    vector<C*> v;

    int ctr; /* counter  */

    @<Declare |Pointer_Vector| functions@>@;


};


@q ** (2) |struct Pointer_Vector| functions.@>
@*1 |struct Pointer_Vector| functions.

\LOG
\initials{LDF 2004.08.25.}
Added this section.
\ENDLOG 

@q *** (3) Constructors.@>
@*2 Constructors.

\LOG
\initials{LDF 2004.08.26.}
Added this section.
\ENDLOG 

@q **** (4) Default constructor.@>
@*3 Default constructor.

\LOG
\initials{LDF 2004.08.26.}
Removed this definition from the |struct Pointer_Vector| 
declaration. 
\ENDLOG 

@<Declare |Pointer_Vector| functions@>=
Pointer_Vector(void);

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
Pointer_Vector<C, D>::Pointer_Vector(void) : ctr(0)
{
    return;
}


@q *** (3) Destructor.  @>
@*2 Destructor.

\LOG
\initials{LDF 2004.09.24.}
Added this function.  
It should fix some memory leaks.
\ENDLOG

@<Declare |Pointer_Vector| functions@>=
~Pointer_Vector(void);

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
Pointer_Vector<C, D>::~Pointer_Vector(void)
{
   for (typename vector<C*>::iterator iter = v.begin();
        iter != v.end();
        iter++)
      {
          delete *iter;
          *iter = 0;
      }

   v.clear();

}  /* End of |~Pointer_Vector| definition.  */

@q *** (3) Operators.@>
@*2 Operators.

\LOG
\initials{LDF 2004.09.29.}
Added this section.
\ENDLOG

@q **** (4) Assignment.@>
@*3 Assignment.

\LOG
\initials{LDF 2004.11.05.}
Added this function.
\ENDLOG


@q ***** (5) Assignment from a |Pointer_Vector<C, D>|.@> 
@*4 Assignment from a {\bf Pointer\_Vector<C, D>}.
\initials{LDF 2005.04.01.}

\LOG
\initials{LDF 2005.04.01.}
Added this function.
\ENDLOG

@q ****** (6) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
const Pointer_Vector<C, D>&
operator=(const Pointer_Vector<C, D>& p);

@q ****** (6) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
const Pointer_Vector<C, D>&
Pointer_Vector<C, D>::operator=(const Pointer_Vector<C, D>& p)
{

   if (this == &p)  /* Prevent self-assignment.  
                       \initials{LDF 2004.11.05.}  */
      return p;

   if (p.ctr <= 0)
      {
         clear();
         return p;
      }

   C* c;

@q ******* (7) Destroy excess pointers on |v|, if necessary.@>

@ Destroy excess pointers on |v|, if necessary.
\initials{LDF 2004.11.05.}

@<Define |Pointer_Vector| functions@>=

   while (ctr > p.ctr)
      {
         c = v.back();
         delete c;
         v.pop_back(); 
         --ctr;
      } /* |while|  */

@q ******* (7) Add pointers to |v|, if necessary.@>

@ Add pointers to |v|, if necessary.
\initials{LDF 2004.11.05.}

@<Define |Pointer_Vector| functions@>=

   try 
      {

          while (ctr < p.ctr)
             {
                 c = new C;
                 v.push_back(c);
                 ++ctr;           
 
             } /* |while|  */

      } /* |try|  */


@q ******** (8) Error handling:  |new C| failed.@> 

@ Error handling:  |new C| failed.
\initials{LDF 2004.11.05.}

@<Define |Pointer_Vector| functions@>=

   catch (bad_alloc)
       {

           string thread_name = "";

#ifdef HAVE_PTHREAD_H

           Thread_Info_Type* thread_info = Thread_Info_Type::get_thread_info();
  
           thread_name = Thread_Info_Type::get_thread_name(thread_info);

#endif /* |HAVE_PTHREAD_H|  */@; 


           cerr_mutex.lock(); 
           cerr << thread_name 
                << "ERROR! In `Pointer_Vector<C, D>::operator=()':"
                << endl << "`new C' failed. "
                << "Rethrowing `bad_alloc'."
                << endl << "Type <RETURN> to continue: ";
           getchar();
           cerr_mutex.unlock();

           throw;

       }  /* |catch (bad_alloc)|  */



@q ******* (7) Assign to the dereferenced elements of |v| @> 
@q ******* (7) from the dereferenced elements of |p.v|    @> 
@q ******* (7) and exit, returning |p|.                   @>                 

@ Assign to the dereferenced elements of |v| 
from the dereferenced elements of |p.v| and exit, 
returning |p|.  
\initials{LDF 2004.11.05.} 

@<Define |Pointer_Vector| functions@>=

   for (int i = 0; i < ctr; ++i)
      {

         /* !! START HERE.  Check precedence of operators.  
            LDF 2004.11.05. */ 

         *v[i]  = *(p.v[i]);

      } /* |for|  */

   return p;
      
}  /* End of |Pointer_Vector<C, D>::operator=| definition.  */

@q ***** (5) Assignment from a |vector<D>&|.@> 
@*4 Assignment from a {\bf vector<D>\AMP}.
\initials{LDF 2005.04.01.}

\LOG
\initials{LDF 2005.04.01.}
Added this function.

\initials{LDF 2007.10.14.}
@:BUG FIX@> BUG FIX:  Now calling |Pointer_Vector<C, D>::clear|.
\ENDLOG

@q ******* (7) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
const Pointer_Vector<C, D>&
operator=(const vector<D>& v);

@q ******* (7) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
const Pointer_Vector<C, D>&
Pointer_Vector<C, D>::operator=(const vector<D>& v)
{

   clear();

   D* d;

   for(typename vector<C>::const_iterator iter = v.begin();
       iter != v.end();
       ++iter)
      {
         d = new D;

         *d = *iter;

         operator+=(d);         
      }

   return *this;
}

@q ***** (5) Assign using same pointers.@> 
@*4 Assign using same pointers.
\initials{LDF 2005.04.13.}

\LOG
\initials{LDF 2005.04.13.}
Added this function.

\initials{LDF 2005.04.13.}
Added optional |Pointer_Vector<C, C>*| argument with default 0.
If it's passed to this function, the pointers are 
cast and pushed onto it.
\ENDLOG

@q ****** (6) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
static
Pointer_Vector<C, C>*
assign_same_pointers(Pointer_Vector<D, D>* d,
                     Pointer_Vector<C, C>* c = 0,  
                     Scanner_Node scanner_node = 0);

@q ****** (6) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
Pointer_Vector<C, C>* 
Pointer_Vector<C, D>::assign_same_pointers(Pointer_Vector<D, D>* d, 
                                           Pointer_Vector<C, C>* c,  
                                           Scanner_Node scanner_node)
{

@q ******* (7) Preliminaries.@>   

#if DEBUG_COMPILE
   bool DEBUG = false; /* |true| */ @; 
#endif /* |DEBUG_COMPILE|  */@; 

   stringstream cerr_strm;

   bool error_stop_value   = true;
   bool warning_stop_value = true;
   string thread_name      = "";

   if (scanner_node)
      scanner_node->get_thread_name_and_stop_values(&thread_name,
                                                    &error_stop_value,
                                                    &warning_stop_value);

   using namespace Scan_Parse;

@q ******* (7).@>

   Pointer_Vector<C>* pvc;

   if (c == static_cast<Pointer_Vector<C, C>*>(0))
     pvc = new Pointer_Vector<C>; 
   else 
     pvc = c;

   if (pvc->ctr > 0)
      pvc->clear();

   pvc->ctr = d->ctr;

   for (typename vector<D*>::iterator iter = d->v.begin();
        iter != d->v.end();
        ++iter)
      {
         pvc->v.push_back(reinterpret_cast<C*>(*iter));
      }
   

@q ******* (7).@>

    return pvc;
      

@q ******* (7) @> 

}  /* End of |Pointer_Vector<C, D>::assign_same_pointers|
      definition.  */


@q ***** (5) Addition with assignment.@>
@*4 Addition with assignment.

@q ****** (6) |C*| argument.@> 
@*5 {\bf C*} argument.
\initials{LDF 2004.09.29.}

\LOG
\initials{LDF 2004.09.29.}
Added this function.

\initials{LDF 2005.02.28.}
Changed the type of the argument from |C*| to |D*|. 
Now casting it to |C*|.
Changed the return type to |void|.
\ENDLOG

@q ******* (7) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
void
operator+=(D* d);

@q ******* (7) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
void
Pointer_Vector<C, D>::operator+=(D* d)
    {
        C* c = static_cast<C*>(d);
        v.push_back(c);
        ctr++;
        return;
    }   

@q ***** (5) Assignment from a |vector<D>&| with addition.@> 
@*4 Assignment from a {\bf vector<D>\AMP} with addition.
\initials{LDF 2007.10.14.}

\LOG
\initials{LDF 2007.10.14.}
Added this function.
\ENDLOG

@q ******* (7) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
void
operator+=(const vector<D>& v);

@q ******* (7) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
void
Pointer_Vector<C, D>::operator+=(const vector<D>& v)
{

   D* d;

   for(typename vector<C>::const_iterator iter = v.begin();
       iter != v.end();
       ++iter)
      {
         d = new D;

         *d = *iter;

         operator+=(d);         
      }

   return;

}

@q ****** (6) |const Pointer_Vector<D>&| argument.@> 
@*5 {\bf const Pointer\_Vector\<D>\AMP} argument.
\initials{LDF 2005.02.28.}

\LOG
\initials{LDF 2005.02.28.}
Added this function.
\ENDLOG

@q ******* (7) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
void
operator+=(const Pointer_Vector<D>& d);

@q ******* (7) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
void
Pointer_Vector<C, D>::operator+=(const Pointer_Vector<D>& d)
{
    for (typename vector<D*>::const_iterator iter = d.v.begin();
         iter != d.v.end();
         ++iter)
       {
           operator+=(static_cast<C*>(*iter));
           ctr++;
       }
}   



@q *** (3) Append copy.@>
@*2 Append copy.
\initials{LDF 2005.02.26.}

@q ***** (5) |const D*| argument.@> 
@*4 {\bf const D*} argument.
\initials{LDF 2005.02.26.}

\LOG
\initials{LDF 2005.02.26.}
Added this function.

\initials{LDF 2005.02.28.}
Changed the type of the first argument from |const C*| 
to |const D*|.  Now casting it to |const C*|.
Changed the return type to int.
\ENDLOG

@q ****** (6) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
int
append_copy(const D* d, Scanner_Node scanner_node = 0);

@q ****** (6) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int
Pointer_Vector<C, D>::append_copy(const D* d, Scanner_Node scanner_node)
{

@q ******* (7) Preliminaries.@>   

#if DEBUG_COMPILE
   bool DEBUG = false; /* |true| */ @; 
#endif /* |DEBUG_COMPILE|  */@; 

   stringstream cerr_strm;

   bool error_stop_value   = true;
   bool warning_stop_value = true;
   string thread_name      = "";

   if (scanner_node)
      scanner_node->get_thread_name_and_stop_values(&thread_name,
                                                    &error_stop_value,
                                                    &warning_stop_value);

   using namespace Scan_Parse;

@q ******* (7).@>

    C* c;
   
    try          
       {
           c = new C;
       }
    
    catch (bad_alloc)
       {
           cerr_strm << thread_name 
                     << "ERROR!  In `Pointer_Vector<C, D>::append_copy':"
                     << endl 
                     << "`new C' failed, throwing `bad_alloc'.  "
                     << "Rethrowing.";

           log_message(cerr_strm);
           cerr_message(cerr_strm, error_stop_value);
           cerr_strm.str("");

           throw;

       }  /* |catch (bad_alloc)|  */

    *c = *(static_cast<const C*>(d));     
 
    operator+=(c);

    return 0;

@q ******* (7) @> 

}  /* End of |Pointer_Vector<C, D>::append_copy(const C* c)|
      definition.  */


@q ***** (5) |const Pointer_Vector<D>&| argument.@> 
@*4 {\bf const Pointer\_Vector<D>\AMP} argument.
\initials{LDF 2005.02.28.}

\LOG
\initials{LDF 2005.02.28.}
Added this function.
\ENDLOG

@q ****** (6) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
int
append_copy(const Pointer_Vector<D>& d, Scanner_Node scanner_node = 0);

@q ****** (6) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int
Pointer_Vector<C, D>::append_copy(const Pointer_Vector<D>& d, 
                                  Scanner_Node scanner_node)
{

@q ******* (7) Preliminaries.@>   

#if DEBUG_COMPILE
   bool DEBUG = false; /* |true| */ @; 
#endif /* |DEBUG_COMPILE|  */@; 

   stringstream cerr_strm;

   bool error_stop_value   = true;
   bool warning_stop_value = true;
   string thread_name      = "";

   if (scanner_node)
      scanner_node->get_thread_name_and_stop_values(&thread_name,
                                                    &error_stop_value,
                                                    &warning_stop_value);

   using namespace Scan_Parse;

@q ******* (7).@>


   try          
      {

@q ******** (8).@>

          for (typename vector<D*>::const_iterator iter = d.v.begin();
               iter != d.v.end();
               ++iter)
             {
                 append_copy(*iter, scanner_node);

             }  /* |for| */

@q ******** (8).@>

      }  /* |try|  */

@q ******* (7) @> 

   catch (bad_alloc)
      {
          cerr_strm << thread_name 
                    << "ERROR!  In `Pointer_Vector<C, D>::append_copy("
                    << "const Pointer_Vector<D>&, Scanner_Node)':"
                    << endl 
                    << "`Pointer_Vector<C, D>::append_copy(const D*, Scanner_Node)' "
                    << "failed, throwing `bad_alloc'.  "
                    << "Rethrowing.";

          log_message(cerr_strm);
          cerr_message(cerr_strm, error_stop_value);
          cerr_strm.str("");

          throw;

      }  /* |catch (bad_alloc)|  */


@q ******* (7) @> 

    return 0;
      

@q ******* (7) @> 

}  /* End of |Pointer_Vector<C, D>::append_copy(const C* c)|
      definition.  */



@q *** (3) Convert pair pointer.@> 
@*2 Convert pair pointer.
\initials{LDF 2005.10.27.}

\LOG
\initials{LDF 2005.10.27.}
Added this function.
\ENDLOG

@q ***** (5) Declaration.@>

@<Declare |Pointer_Vector| functions@>=
int
convert_pair_pointer(pair<C, C>* p, bool delete_pair = true);

@q ***** (5) Definition.@>
@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int
Pointer_Vector<C, D>::convert_pair_pointer(pair<C, C>* p, bool delete_pair)
{
   if (!p)
      return 1;

   clear();
   v.push_back(new C);
   v.push_back(new C);
   *(v[0]) = p->first;
   *(v[1]) = p->second;
   ctr = 2;

   if (delete_pair)
      {
         delete p;
         p = 0;
      }

   return 0;
}

@q *** (3) Pop back.@>   
@*2 Pop back.
\initials{LDF 2005.02.28.}

\LOG
\initials{LDF 2005.02.28.}
Added this function.
\ENDLOG

@<Declare |Pointer_Vector| functions@>=
int
pop_back(bool delete_pointer = false);

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int
Pointer_Vector<C, D>::pop_back(bool delete_pointer)
{

   if (delete_pointer)
      delete v.back();

   v.pop_back();

   return 0;

}  /* End of |template <class C, class D> int
              Pointer_Vector<C, D>::pop_back(bool delete_pointer)|
      definition.  */


@q *** (3) Predicates.@> 
@*2 Predicates.
\initials{LDF 2007.07.22.}

\LOG
\initials{LDF 2007.07.22.}
Added this section.
\ENDLOG


@q **** (4) Are Distinct.@> 
@*3 Are Distinct.
\initials{LDF 2007.07.22.}

If the |real tolerance| argument is $< 0$, 
the |real factor| argument can be used to multiply the default 
value used for the tolerance in a given type's version of 
|is_equal|.  This is needed in the case of |Point|, because the value
returned by |Point::epsilon| is too small for use when comparing 
|Points|.  See the discussion of this in the log for
|Point::operator==| in \filename{points.web}.
\initials{LDF 2007.07.22.}

\LOG
\initials{LDF 2007.07.22.}
Added this function.
\ENDLOG

@q ***** (5) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
bool
are_distinct(real tolerance = -1, real factor = 1, void* parameter = 0);


@q ***** (5) Definition.@> 
@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
bool
Pointer_Vector<C, D>::are_distinct(real tolerance, 
                                   real factor, 
                                   void* parameter)
{

@q ****** (6) Preliminaries.@>   

#if DEBUG_COMPILE
   bool DEBUG = false; /* |true| */ @; 
#endif /* |DEBUG_COMPILE|  */@; 

   stringstream cerr_strm;

   bool error_stop_value   = true;
   bool warning_stop_value = true;
   string thread_name      = "";

   Scanner_Node scanner_node = static_cast<Scanner_Node>(parameter);

   if (scanner_node)
      scanner_node->get_thread_name_and_stop_values(&thread_name,
                                                    &error_stop_value,
                                                    &warning_stop_value);

   using namespace Scan_Parse;

@q ****** (6)@> 

   int i;
   int j;

   size_t size = v.size();

   if (tolerance < 0)
      tolerance = C::epsilon() * factor;

   for (i = 0; i < size - 1; ++i)
   {
       for (j = i + 1; j < size; ++j)
       {
           if (v[i]->is_equal(*v[j], tolerance, parameter))
              return false;
       }
   } 

   return true;

}  /* End of |Pointer_Vector<C, D>::are_distinct| definition.  */

@q *** (3) Conversion.@>   
@*3 Conversion.
\initials{LDF 2005.04.11.}

\LOG
\initials{LDF 2005.04.11.}
Added this function.  I wasn't able to define a version of |operator=| 
to do the job.
It was necessary to use |reinterpret_cast| 
because |static_cast| failed when I tried to convert a 
|Pointer_Vector<Shape>*| to a |Pointer_Vector<Polygon>*|.

\initials{LDF 2005.04.11.}
@:BUG FIX@> BUG FIX:  Now returning 0 if |d == 0 || d->ctr == 0|.

\initials{LDF 2005.04.14.}
@:BUG FIX@> BUG FIX:  Now incrementing |c->ctr|.


\initials{LDF 2013.11.10.}
@:BUG FIX@> BUG FIX:  Now explicitly resizing |c->v| with |static_cast<C*>(0)|
as the value.  Previously, |operator+=| was called to push the pointers onto 
|c->v|.  Now, the existing NULL values are replaced.
\par
I don't think this should be necessary:  The older code worked with GCC 4.6.2, 
but it caused a compilation error with GCC 4.8.2:  Apparently, |vector::resize| 
was called with |Shape| instead of |Shape *| as the value type, which didn't work,
because |Shape| is an abstract class.
\par
In addition, I've had to change the type of derivation of |Path| from |Shape| from
|protected| to |public|.
\ENDLOG

@q ***** (5) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
static
Pointer_Vector<C, C>* 
convert(Pointer_Vector<D, D>* d); 

@q ***** (5) Definition.@> 

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
Pointer_Vector<C, C>* 
Pointer_Vector<C, D>::convert(Pointer_Vector<D, D>* d)
{
   if (   d == static_cast<Pointer_Vector<D, D>*>(0) 
       || d->ctr == 0)
      return 0;
   
   Pointer_Vector<C, C>* c = new Pointer_Vector<C, C>;

   c->v.resize(d->v.size(), static_cast<C*>(0));

   int i = 0;
 
   for (typename vector<D*>::iterator iter = d->v.begin();
        iter != d->v.end();
        ++iter)
      {
          c->v[i] = static_cast<C*>(*iter);

          ++(c->ctr);
      }

   d->clear(false);

   delete d;
   d = 0;

   return c;

}   /* End of |Pointer_Vector<C, D>::convert(Pointer_Vector<D, D>*& d)|
       definition.  */



@q *** (3) Clear.@>
@*2 Clear.
\initials{LDF 2004.10.01.}

\LOG
\initials{LDF 2004.10.01.}
Added this function.

\initials{LDF 2005.02.26.}
Added optional |bool delete_pointers| argument with default |true|.
\ENDLOG

@<Declare |Pointer_Vector| functions@>=
int
clear(bool delete_pointers = true);

@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int
Pointer_Vector<C, D>::clear(bool delete_pointers)
{

    ctr = 0;

    if (delete_pointers)
       {
           for (typename vector<C*>::iterator iter = v.begin();
                iter != v.end();
                iter++)
              {
                  delete *iter;
                  *iter = 0;

              } /* |for|  */  

       }  /* |if (delete_pointers)|  */

    v.clear();
        
}  /* End of |Pointer_Vector<C, D>::clear| definition. */


@q *** (3) Cull.@>
@*2 Cull.
\initials{LDF 2007.07.22.}

@q **** (4) Non-|const| version.@> 
@*3 Non-{\bf const} version.
@^\cfunc{Pointer\_Vector}{cull}@>
\cfunctexi{Pointer\_Vector}{cull}
\initials{LDF 2007.07.22.}

This function requires the existence of a function |C::is_equal|.  Currently,
this function only exists for |class Point|.
\initials{LDF 2007.07.27.}

\LOG
\initials{LDF 2007.07.22.}
Added this function.
\ENDLOG

@q ***** (5) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
int
cull(const unsigned short comparison = Sorting::SORTING_EQUAL,
     real tolerance = -1,
     Scanner_Node scanner_node = 0,
     C* c = 0);


@q ***** (5) Definition.@> 
@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int
Pointer_Vector<C, D>::cull(const unsigned short comparison,
                           real tolerance,
                           Scanner_Node scanner_node, 
                           C* c)
{
 
@q ****** (6) Preliminaries.@>   

#if DEBUG_COMPILE
   bool DEBUG = false; /* |true| */ @; 
#endif /* |DEBUG_COMPILE|  */@; 

   stringstream cerr_strm;

   bool error_stop_value   = true;
   bool warning_stop_value = true;
   string thread_name      = "";

   if (scanner_node)
      scanner_node->get_thread_name_and_stop_values(&thread_name,
                                                    &error_stop_value,
                                                    &warning_stop_value);

   using namespace Scan_Parse;

@q ****** (6)@> 

#if DEBUG_COMPILE
   if (DEBUG)
   {
       cerr_strm << thread_name 
                 << "Entering `Pointer_Vector::cull'.";

       log_message(cerr_strm);
       cerr_message(cerr_strm);
       cerr_strm.str("");

   }  /* |if (DEBUG)|  */

#endif /* |DEBUG_COMPILE|  */@; 

@q ****** (6)@> 

    if (comparison == Sorting::SORTING_EQUAL)
    {  

        vector<C*> temp_vector = v;

        v.clear();
        ctr = 0;

        typename vector<C*>::iterator i;
        typename vector<C*>::const_iterator i_end = temp_vector.end();
        --i_end;

        typename vector<C*>::iterator j;

        int i_ctr = 0; 
        int j_ctr = 0; 


@q ******* (7)@> 

        for (i = temp_vector.begin(); i != i_end; ++i)
        {

             j_ctr = i_ctr + 1;
             
             j = i;
             ++j;

             if (*i == static_cast<C*>(0))
             {
                ++i_ctr;
                continue;
             }

             else
             {
                v.push_back(*i);
                ++ctr;

             }  /* |else|  */


@q ******** (8)@> 

             for (;j != temp_vector.end(); ++j)
             {
                if (*j == static_cast<C*>(0))
                ;
                else if ((**i).is_equal(**j, tolerance))
                {
                   delete temp_vector[j_ctr];
                   temp_vector[j_ctr] = 0;                
                }
                
                ++j_ctr;

             }  /* inner |for|  */

@q ******** (8)@>         
             
             ++i_ctr;


        }  /* outer |for|  */

@q ******* (7)@> 

   if (temp_vector.back() != static_cast<C*>(0))
   {
       v.push_back(temp_vector.back());
       ++ctr;
   }

@q ******* (7)@> 

    }  /* |if (comparison == Sorting::SORTING_EQUAL)|  */ 


@q ****** (6)@> 

#if DEBUG_COMPILE
   if (DEBUG)
   {
       cerr_strm << thread_name 
                 << "Exiting `Pointer_Vector::cull' "
                 << "successfully with return value 0.";

       log_message(cerr_strm);
       cerr_message(cerr_strm);
       cerr_strm.str("");

   }  /* |if (DEBUG)|  */

#endif /* |DEBUG_COMPILE|  */@; 

    return 0;

}  /* End of |Pointer_Vector<C, D>::cull| definition 
      (non-|const| version).  */

@q **** (4) |const| version.@> 
@*3 {\bf const} version.
@^\cfunc{Pointer\_Vector}{cull}@>
\cfunctexi{Pointer\_Vector}{cull}
\initials{LDF 2007.07.22.}

\LOG
\initials{LDF 2007.07.22.}
Added this function.
\ENDLOG

@q ***** (5) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
Pointer_Vector<C, D>*
cull(const unsigned short comparison = Sorting::SORTING_EQUAL,
     real tolerance = -1,
     Scanner_Node scanner_node = 0,
     C* c = 0) const;



@q ***** (5) Definition.@> 
@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
Pointer_Vector<C, D>*
Pointer_Vector<C, D>::cull(const unsigned short comparison,
                           real tolerance,  
                           Scanner_Node scanner_node,
                           C* c) const      
{

    /* START HERE!!  LDF 2007.07.22.  */ 

    return 0;

}  /* End of |Pointer_Vector<C, D>::cull| definition (|const| version).  */



@q *** (3) Reverse.@>
@*2 Reverse.
\initials{LDF 2007.08.14.}

\LOG
\initials{LDF 2007.08.14.}
Added this function.
\ENDLOG

@q **** (4) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
int 
reverse(Scanner_Node scanner_node = 0);

@q **** (4) Definition.@> 
@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int 
Pointer_Vector<C, D>::reverse(Scanner_Node scanner_node)
{
   std::reverse(v.begin(), v.end());
   return 0;

}  /* End of |Pointer_Vector<C, D>::reverse| definition.  */

@q *** (3) Show.@>
@*2 Show.

The template parameter for a |Pointer_Vector| must be a class that 
defines a member function |show(string)|.
\initials{LDF 2004.08.25.}

\LOG
\initials{LDF 2004.08.25.}
Added this function.

\initials{LDF 2004.08.26.}
Minor additions.

\initials{LDF 2007.07.27.}
Added default for |string| argument (|""|).

\initials{LDF 2007.07.27.}
@:BUG FIX@> BUG FIX:  No longer showing null elements of |vector<C*> v|.

\initials{LDF 2007.07.27.}
Added optional |Scanner_Node scanner_node| argument 
with the default 0.
\ENDLOG 

@q **** (4) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
int 
show(string s = "", Scanner_Node scanner_node = 0) const;

@q **** (4) Definition.@> 
@
@<Define |Pointer_Vector| functions@>=
template <class C, class D>
int 
Pointer_Vector<C, D>::show(string s, Scanner_Node scanner_node) const
{

@q ***** (5) Preliminaries.@>   

#if DEBUG_COMPILE
   bool DEBUG = false; /* |true| */ @; 
#endif /* |DEBUG_COMPILE|  */@; 

   stringstream cerr_strm;

   bool error_stop_value   = true;
   bool warning_stop_value = true;
   string thread_name      = "";

   if (scanner_node)
      scanner_node->get_thread_name_and_stop_values(&thread_name,
                                                    &error_stop_value,
                                                    &warning_stop_value);

   using namespace Scan_Parse;


@q ***** (5)@> 

   stringstream ctr_strm;

   if (s == "")
      s = "Pointer_Vector:";

   cerr_strm << s << endl
             << "size of vector: " << ctr;

   log_message(cerr_strm); 
   cerr << cerr_strm.str() << endl;
   cerr_strm.str("");

   int i = 0;

   for (typename vector<C*>::const_iterator iter = v.begin();
        iter != v.end();
        iter++)
      {
         ctr_strm << i++ << ":";

         if (*iter != static_cast<C*>(0))
            (*iter)->show(ctr_strm.str());
         else 
            cerr_strm << " 0";

         ctr_strm.str(""); 

      }  /* |for|  */

   return 0;

} /* End of |Pointer_Vector<C, D>::show| definition.  */


@q *** (3) Specializations.@>
@*2 Specializations.
\initials{LDF 2007.07.20.}

\LOG
\initials{LDF 2007.07.20.}
Added this section.
\ENDLOG

@q **** (4) |Pointer_Vector<Point, Point>| specializations.@> 
@*3 {\bf Pointer\_Vector\<Point, Point>} specializations.
\initials{LDF 2007.07.20.}

\LOG
\initials{LDF 2007.07.20.}
Added this section.
\ENDLOG

@q ***** (5) Rectify.@>
@*4 Rectify.
\initials{LDF 2007.07.27.}

\LOG
\initials{LDF 2007.07.27.}
Added this function declaration.  
The function must be defined in \filename{pntrvcf0.web}, because
it requires types which are not fully defined when this file is compiled.

\initials{LDF 2007.08.06.}
Added optional |Transform* transform| argument.  The default is 0.

\initials{LDF 2007.08.06.}
Added optional |bool do_transform| argument with the default |true|.
\ENDLOG

@q ****** (6) Declaration.@> 

@<Declare |Pointer_Vector| functions@>=
int
rectify(Scanner_Node scanner_node = 0,
        bool do_test = true,
        bool do_cull = true,
        bool do_transform = true,
        real tolerance = -1,
        Transform* transform = 0,
        Point* p = 0);

@q ***** (5) Get |Conic_Section_Lattice|.@> 
@ Get {\bf Conic\_Section\_Lattice}.
\initials{LDF 2007.07.29.}

\LOG
\initials{LDF 2007.07.29.}
Added this function declaration.  
The function must be defined in \filename{pntrvcf0.web}, because
it requires |Conic_Section_Lattice|, which isn't fully defined 
when this file is compiled.
\ENDLOG

@<Declare |Pointer_Vector| functions@>=
Conic_Section_Lattice*
get_conic_section_lattice(Scanner_Node scanner_node = 0,
                          bool do_cull = false,
                          bool do_rectify = false,
                          real tolerance = -1,
                          bool do_test = false,
                          bool do_transform = false,
                          Transform* t = 0);



@q ****** (6)@> 

@q ***** (5)@>

@q **** (4)@>

@q *** (3)@>

@q ** (2)@> 

@q * (1) Putting |struct Pointer_Vector| together.@>
@* Putting {\bf struct Pointer\_Vector} together.

\immediate\write\functexifile{^^JEnd of file:  pntrvctr.web^^J}

@q ** This is what's compiled.@>
@ This is what's compiled.
@c
@<Include files@>@;
@<Utility classes@>@;
@<Define |Pointer_Vector| functions@>@;

@q ** This is what's written to \filename{pntrvctr.h}.@>
@ This is what's written to the \filename{pntrvctr.h}.
@(pntrvctr.h@>=
@<Utility classes@>@;
@<Define |Pointer_Vector| functions@>@;

@q * Emacs-Lisp code for use in indirect buffers when using the          @>
@q   GNU Emacs editor.  The local variable list is not evaluated when an @>
@q   indirect buffer is visited, so it's necessary to evaluate the       @>
@q   following s-expression in order to use the facilities normally      @>
@q   accessed via the local variables list.                              @>
@q   \initials{LDF 2004.02.12}.                                          @>
@q   (progn (cweb-mode) (outline-minor-mode t))                          @>

  
@q * Local variables for Emacs.@>
@q Local Variables: @>
@q mode:CWEB @>
@q eval:(display-time) @>
@q run-cweave-on-file:"3DLDFprg.web" @>
@q eval:(read-abbrev-file) @>
@q indent-tabs-mode:nil @>
@q eval:(outline-minor-mode) @>
@q fill-column:80 @>
@q End: @>