d_array_point_locator.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//


#ifndef D_ARRAY_POINT_LOCATOR_H
#define D_ARRAY_POINT_LOCATOR_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef D_BIN_POINT_LOCATOR_H
#include "SheafSystem/d_bin_point_locator.h"
#endif

namespace geometry
{

template <int DC, int DB>
class d_bounding_box;

template <int DC, int DB>
class SHEAF_DLL_SPEC d_array_point_locator : public d_bin_point_locator<DC, DB>
{

  // ===========================================================
  // ===========================================================

public:

  typedef singly_linked_list<const d_bounding_box<DC, DB>*> box_list_type;

  typedef std::set<const d_bounding_box<DC, DB>*> box_set_type;
  
  virtual void insert_box(d_bounding_box<DC, DB>* xbox);

  virtual void remove_box(d_bounding_box<DC, DB>* xbox);

  using d_bin_point_locator<DC, DB>::box_list;
  
  virtual const box_list_type& box_list(sec_vd_value_type* xpt,
                                        size_type xpt_ub) const;

  virtual void box_list(const section_evaluator& xeval,
            sec_vd_value_type* xdofs, 
            size_type xdofs_ub,
            box_list_type& xresult) const;

  virtual void box_list(d_bounding_box<DC, DB>* xbox, box_set_type& xresult) const;

  virtual bool contains_box(d_bounding_box<DC, DB>* xbox) const;

  virtual void clear();



  // ===========================================================
  // ===========================================================

  d_array_point_locator(sec_ed& xcoords, 
            const block<size_type>& xbin_ub, 
            bool xpopulate = true, 
            size_type xeval_capacity = 256);

  d_array_point_locator(sec_ed& xcoords, 
            bool xpopulate = true, 
            size_type xeval_capacity = 256);

  virtual ~d_array_point_locator();

  size_type size() const;

  size_type capacity() const;

  void to_stream(std::ostream& xos) const;

protected:

  d_array_point_locator() {};

  d_array_point_locator(const d_array_point_locator& xother) {};

  virtual d_array_point_locator& operator=(const point_locator& xother) {return *this;};

  d_array_point_locator& operator=(const d_array_point_locator& xother) {return *this;};

  void update_bins();

  block<box_list_type> _bins;

  size_type bin_id(const d_bin_coordinates<DC, DB>& xcoord) const;

  size_type bin_id(const block<size_type>& xid) const;

  size_type bin_id(size_type xi, size_type xj) const;

  size_type bin_id(size_type xi, size_type xj, size_type xk) const;



  // ===========================================================
  // ===========================================================

public:

  virtual bool invariant() const;


};


// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================

template <int DC, int DB>
SHEAF_DLL_SPEC 
std::ostream&
operator << (std::ostream& xos, const d_array_point_locator<DC, DB>& xpl);

template <int DC, int DB>
SHEAF_DLL_SPEC 
std::ostream&
operator << (std::ostream& xos, const singly_linked_list<const d_bounding_box<DC, DB>*>& xbl);


// ============================================================================
// SPECIALIZATIONS
// ============================================================================

//
// Insert xbox into this; 
// DC = 1, DB = 1 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<1, 1>::
insert_box(d_bounding_box<1, 1>* xbox);

//
// Insert xbox into this; 
// DC = 2, DB = 2 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<2, 2>::
insert_box(d_bounding_box<2, 2>* xbox);

//
// Insert xbox into this;
// DC = 3, DB = 1 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 1>::
insert_box(d_bounding_box<3, 1>* xbox);

//
// Insert xbox into this;
// DC = 3, DB = 2 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 2>::
insert_box(d_bounding_box<3, 2>* xbox);

//
// Insert xbox into this;
// DC = 3, DB = 3 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 3>::
insert_box(d_bounding_box<3, 3>* xbox);
 
//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 1, DB = 1 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<1, 1>::
box_list(const section_evaluator& xeval, sec_vd_value_type* xdofs, size_type xdofs_ub, box_list_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 2, DB = 2 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<2, 2>::
box_list(const section_evaluator& xeval, sec_vd_value_type* xdofs, size_type xdofs_ub, box_list_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 3, DB = 1 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 1>::
box_list(const section_evaluator& xeval, sec_vd_value_type* xdofs, size_type xdofs_ub, box_list_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 3, DB = 2 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 2>::
box_list(const section_evaluator& xeval, sec_vd_value_type* xdofs, size_type xdofs_ub, box_list_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 3, DB = 3 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 3>::
box_list(const section_evaluator& xeval, sec_vd_value_type* xdofs, size_type xdofs_ub, box_list_type& xresult) const;
 
//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 1, DB = 1 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<1, 1>::
box_list(d_bounding_box<1, 1>* xbox, box_set_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 2, DB = 2 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<2, 2>::
box_list(d_bounding_box<2, 2>* xbox, box_set_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 3, DB = 1 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 1>::
box_list(d_bounding_box<3, 1>* xbox, box_set_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 3, DB = 2 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 2>::
box_list(d_bounding_box<3, 2>* xbox, box_set_type& xresult) const;

//
// Get list of boxes possibly overlapping the cell described by xeval, xdofs;
// DC = 3, DB = 3 specialization.
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 3>::
box_list(d_bounding_box<3, 3>* xbox, box_set_type& xresult) const;

//
// Remove xbox from this;
// DC = 1, DB = 1 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<1, 1>::
remove_box(d_bounding_box<1, 1>* xbox);

//
// Remove xbox from this;
// DC = 2, DB = 2 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<2, 2>::
remove_box(d_bounding_box<2, 2>* xbox);

//
// Remove xbox from this;
// DC = 3, DB = 1 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 1>::
remove_box(d_bounding_box<3, 1>* xbox);

//
// Remove xbox from this;
// DC = 3, DB = 2 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 2>::
remove_box(d_bounding_box<3, 2>* xbox);

//
// Remove xbox from this;
// DC = 3, DB = 3 specialization
//
template <>
SHEAF_DLL_SPEC
void
d_array_point_locator<3, 3>::
remove_box(d_bounding_box<3, 3>* xbox);

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<1, 1>::
bin_id(const d_bin_coordinates<1, 1>& xcoord) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<2, 2>::
bin_id(const d_bin_coordinates<2, 2>& xcoord) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<3, 1>::
bin_id(const d_bin_coordinates<3, 1>& xcoord) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<3, 2>::
bin_id(const d_bin_coordinates<3, 2>& xcoord) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<3, 3>::
bin_id(const d_bin_coordinates<3, 3>& xcoord) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<1, 1>::
bin_id(const block<size_type>& xid) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<2, 2>::
bin_id(const block<size_type>& xid) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<3, 1>::
bin_id(const block<size_type>& xid) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<3, 2>::
bin_id(const block<size_type>& xid) const;

template <>
SHEAF_DLL_SPEC
size_type
d_array_point_locator<3, 3>::
bin_id(const block<size_type>& xid) const;


}

// namespace geometry/

#endif // D_ARRAY_POINT_LOCATOR_H