\begin{ccRefClass}{Range_tree_k<Traits>}

\ccDefinition

An object of the class  \ccClassName\ is a $k$-dimensional range tree
that can store k-dimensional keys of type \ccc{Key}. 
The class allows to perform
window queries on the keys.  The class \ccClassName\ is parameterized with
a range tree traits class \ccc{Traits} that defines, among other things, 
the type of the \ccc{Key}. 

\cgal\ provides traits class implementations that allow to use 
the range tree with point classes from the \cgal\ kernel as keys.
These classes are \ccc{CGAL::Range_segment_tree_traits_set_2<R>},
\ccc{CGAL::Range_segment_tree_traits_set_3<R>}, 
\ccc{CGAL::Range_tree_traits_map_2<R>} and
\ccc{CGAL::Range_tree_traits_map_3<R>}.  The concept
RangeSegmentTreeTraits\_d defines the requirements that range tree traits
classes must fulfill. This allows the advanced user to develop further
range tree traits classes.

\ccInclude{CGAL/Range_tree_k.h}


\ccTypes

\ccNestedType{Traits}{the type of the range tree traits class.}
\ccTypedef{typedef Traits::Key Key;}{}
\ccTypedef{typedef Traits::Interval Interval;}{}

\ccCreationVariable{R}


\ccCreation

\ccConstructor{Range_tree_k ();} 
{Introduces an empty range tree \ccVar.}

\ccConstructor{template < class ForwardIterator >
               Range_tree_k (ForwardIterator first, 
                                     ForwardIterator last);}
{Introduces a range tree \ccVar\ and initializes it with the data
in the range \ccc{[first, last)}.
\ccPrecond{\ccc{value_type(first) == Traits::Key}.}}

\ccOperations

\ccMethod{template < class ForwardIterator >
          void 
          make_tree(ForwardIterator first,
                    ForwardIterator last);}%
{Introduces a range tree \ccVar\ and initializes it with the data
in the range \ccc{[first, last)}. This function can only be applied
once on an empty range tree.
\ccPrecond{\ccc{value_type(first) == Traits::Key}.}}


\ccMethod{template < class OutputIterator >
          OutputIterator
          window_query(Interval window,
                       OutputIterator out);}%
{writes all data that are in the interval \ccc{window} to the container
where \ccc{out} points to, and returns an output iterator that points
to the last location the function wrote to.
\ccPrecond{\ccc{value_type(out) == Traits::Key}.}}


\ccExample
The following example program uses the predefined \ccc{
  Range_tree_2} data structure together with the predefined traits
  class \ccc{Range_tree_map_traits_2} which has two template
  arguments specifying the
  type of the point data in each dimension
  (\ccc{CGAL::Cartesian<double>}) and the value type of the
  2-dimensional point data (\ccc{char}). Therefore the \ccc{
  Range_tree_2} is defined on 2-dimensional point data
  (\ccc{CGAL::Point_2<Cartesian<double> >}) each of which is
  associated with a character.
Then, a few data items are created and put into a list. After
  that the tree is constructed according to that list, a window
  query is performed, and the query elements are given out.

\begin{verbatim}

#include <CGAL/Cartesian.h>
#include <CGAL/Range_segment_tree_traits.h>
#include <CGAL/Range_tree_k.h>

typedef CGAL::Cartesian<double> K;
typedef CGAL::Range_tree_map_traits_2<K, char> Traits;
typedef CGAL::Range_tree_2<Traits> Range_tree_2_type;

int main()
{
  typedef Traits::Key Key;                
  typedef Traits::Interval Interval;    

  std::vector<Key> InputList, OutputList;
  InputList.push_back(Key(K::Point_2(8,5.1), 'a'));
  InputList.push_back(Key(K::Point_2(1,1.1), 'b'));
  InputList.push_back(Key(K::Point_2(3,2.1), 'c'));

  Range_tree_2_type Range_tree_2(InputList.begin(),InputList.end());
  Interval win(Interval(K::Point_2(4,8.1), K::Point_2(5,8.2)));
  std::cout << "\n Window Query:\n ";
  Range_tree_2.window_query(win, std::back_inserter(OutputList));
  std::vector<Key>::iterator current=OutputList.begin();
  while(current!=OutputList.end()){
    std::cout << (*current).first.x() << "," << (*current).first.y()
         << ":" << (*current++).second << std::endl;
  }
}
\end{verbatim}
\end{ccRefClass}
