cctbx/geometry_restraints/sorted_asu_proxies.h

#ifndef CCTBX_GEOMETRY_RESTRAINTS_SORTED_ASU_PROXIES_H
#define CCTBX_GEOMETRY_RESTRAINTS_SORTED_ASU_PROXIES_H

#include <cctbx/crystal/direct_space_asu.h>

namespace cctbx { namespace geometry_restraints {

  typedef direct_space_asu::asu_mapping_index      asu_mapping_index;
  typedef direct_space_asu::asu_mapping_index_pair asu_mapping_index_pair;
  typedef direct_space_asu::asu_mappings<>         asu_mappings;


  template <typename SimpleProxyType,
            typename AsuProxyType>
  class sorted_asu_proxies
  {
    public:
      sorted_asu_proxies()
      :
        asu_mappings_(0)
      {}

      sorted_asu_proxies(
        boost::shared_ptr<
          direct_space_asu::asu_mappings<> > const& asu_mappings)
      :
        asu_mappings_owner_(asu_mappings),
        asu_mappings_(asu_mappings.get())
      {
        if (asu_mappings_ != 0) {
          asu_active_flags.resize(
            asu_mappings_->mappings_const_ref().size(), false);
        }
      }

      boost::shared_ptr<direct_space_asu::asu_mappings<> > const&
      asu_mappings() const
      {
        CCTBX_ASSERT(asu_mappings_ != 0);
        return asu_mappings_owner_;
      }

      bool
      process(SimpleProxyType const& proxy)
      {
        simple.push_back(proxy);
        return false;
      }

      void
      process(af::const_ref<SimpleProxyType> const& proxies)
      {
        for(std::size_t i=0;i<proxies.size();i++) process(proxies[i]);
      }

      bool
      process(AsuProxyType const& proxy)
      {
        CCTBX_ASSERT(asu_mappings_ != 0 && proxy.is_active());
        if (asu_mappings_->is_simple_interaction(proxy)) {
          if (proxy.i_seq < proxy.j_seq) {
            simple.push_back(proxy.as_simple_proxy());
          }
          return false;
        }
        push_back(proxy);
        return true;
      }

      void
      process(af::const_ref<AsuProxyType> const& proxies)
      {
        for(std::size_t i=0;i<proxies.size();i++) process(proxies[i]);
      }

      void
      push_back(AsuProxyType const& proxy)
      {
        CCTBX_ASSERT(asu_mappings_ != 0);
        CCTBX_ASSERT(proxy.i_seq < asu_active_flags.size());
        CCTBX_ASSERT(proxy.j_seq < asu_active_flags.size());
        asu.push_back(proxy);
        asu_active_flags[proxy.i_seq] = true;
        asu_active_flags[proxy.j_seq] = true;
      }

      void
      push_back(af::const_ref<AsuProxyType> const& proxies)
      {
        for(std::size_t i=0;i<proxies.size();i++) push_back(proxies[i]);
      }

      std::size_t
      n_total() const { return simple.size() + asu.size(); }

    protected:
      boost::shared_ptr<direct_space_asu::asu_mappings<> > asu_mappings_owner_;
      const direct_space_asu::asu_mappings<>* asu_mappings_;

    public:
      af::shared<SimpleProxyType> simple;
      af::shared<AsuProxyType> asu;
      std::vector<bool> asu_active_flags;
  };

}} // namespace cctbx::geometry_restraints

#endif // CCTBX_GEOMETRY_RESTRAINTS_SORTED_ASU_PROXIES_H

---