kernel/singleton_macros.h

Go to the documentation of this file.

/**
 *  \file IMP/kernel/singleton_macros.h
 *  \brief Macros for various classes.
 *
 *  This file is generated by a script (core/tools/make-containers).
 *  Do not edit directly.
 *
 *  Copyright 2007-2014 IMP Inventors. All rights reserved.
 */

#ifndef IMPKERNEL_SINGLETON_MACROS_H
#define IMPKERNEL_SINGLETON_MACROS_H

#include "internal/TupleRestraint.h"
#include "internal/functors.h"
#include "container_macros.h"
#include <IMP/base/object_macros.h>
#include <algorithm>

/** Define
    - IMP::kernel::SingletonScore::evaluate_indexes()
    - IMP::kernel::SingletonScore::evaluate_if_good_indexes()
 */
#define IMP_SINGLETON_SCORE_METHODS(Name)                                      \
  double evaluate_indexes(kernel::Model *m, const kernel::ParticleIndexes &p,          \
                          DerivativeAccumulator *da, unsigned int lower_bound, \
                          unsigned int upper_bound) const IMP_FINAL {          \
    double ret = 0;                                                            \
    for (unsigned int i = lower_bound; i < upper_bound; ++i) {                 \
      ret += evaluate_index(m, p[i], da);                                      \
    }                                                                          \
    return ret;                                                                \
  }                                                                            \
  double evaluate_if_good_indexes(                                             \
      kernel::Model *m, const kernel::ParticleIndexes &p, DerivativeAccumulator *da,   \
      double max, unsigned int lower_bound, unsigned int upper_bound) const {  \
    double ret = 0;                                                            \
    for (unsigned int i = lower_bound; i < upper_bound; ++i) {                 \
      ret += evaluate_if_good_index(m, p[i], da, max - ret);                   \
      if (ret > max) return std::numeric_limits<double>::max();                \
    }                                                                          \
    return ret;                                                                \
  }

//! Define extra the functions needed for a SingletonPredicate
#define IMP_SINGLETON_PREDICATE_METHODS(Name)                                  \
  int get_value(kernel::Particle* a) const {                                        \
    return get_value_index(IMP::kernel::internal::get_model(a),                \
                           IMP::kernel::internal::get_index(a));               \
  }                                                                            \
  Ints get_value(const kernel::ParticlesTemp &o) const {                          \
    Ints ret(o.size());                                                        \
    for (unsigned int i = 0; i < o.size(); ++i) {                              \
      ret[i] += Name::get_value(o[i]);                                         \
    }                                                                          \
    return ret;                                                                \
  }                                                                            \
  Ints get_value_index(kernel::Model *m, const kernel::ParticleIndexes &o) const {     \
    Ints ret(o.size());                                                        \
    for (unsigned int i = 0; i < o.size(); ++i) {                              \
      ret[i] += Name::get_value_index(m, o[i]);                                \
    }                                                                          \
    return ret;                                                                \
  }                                                                            \
  IMP_IMPLEMENT_INLINE_NO_SWIG(                                                \
      void remove_if_equal(kernel::Model *m, kernel::ParticleIndexes &ps,              \
                           int value) const,                                   \
  {                                                                            \
        ps.erase(                                                              \
            std::remove_if(ps.begin(), ps.end(),                               \
                           IMP::kernel::internal::PredicateEquals<Name, true>( \
                               this, m, value)),                               \
            ps.end());                                                         \
      });                                                                      \
  IMP_IMPLEMENT_INLINE_NO_SWIG(void remove_if_not_equal(kernel::Model *m,      \
                                                        kernel::ParticleIndexes &ps,   \
                                                        int value) const,      \
  {                                                                            \
    ps.erase(                                                                  \
        std::remove_if(ps.begin(), ps.end(),                                   \
                       IMP::kernel::internal::PredicateEquals<Name, false>(    \
                           this, m, value)),                                   \
        ps.end());                                                             \
  });

//! Use IMP_SINGLETON_MODIFIER() instead
#define IMP_SINGLETON_DERIVATIVE_MODIFIER(Name) IMP_SINGLETON_MODIFIER(Name)

/** Define
    - IMP::kernel::SingletonModifier::apply_indexes()
*/
#define IMP_SINGLETON_MODIFIER_METHODS(Name)                             \
  virtual void apply_indexes(kernel::Model *m, const kernel::ParticleIndexes &o, \
                             unsigned int lower_bound,                   \
                             unsigned int upper_bound) const IMP_FINAL { \
    for (unsigned int i = lower_bound; i < upper_bound; ++i) {           \
      apply_index(m, o[i]);                                              \
    }                                                                    \
  }

//! Use IMP_INDEX_SINGLETON_MODIFIER instead
#define IMP_INDEX_SINGLETON_DERIVATIVE_MODIFIER(Name) \
  IMP_INDEX_SINGLETON_MODIFIER(Name)

#ifndef IMP_DOXYGEN
#define IMP_IMPLEMENT_SINGLETON_CONTAINER(Name)                          \
  IMP_IMPLEMENT_INLINE(void do_apply(const SingletonModifier *sm) const, \
  { apply_generic(sm); });                                               \
  virtual ParticleIndexes get_all_possible_indexes() const IMP_OVERRIDE; \
  IMP_OBJECT_NO_WARNING(Name)
#endif

/** Use this to fill in container methods
    IMP::kernel::SingletonContainer::do_apply()
*/
#define IMP_SINGLETON_CONTAINER_METHODS(Name) \
  void do_apply(const SingletonModifier *sm) const { apply_generic(sm); }

#endif /* IMPKERNEL_SINGLETON_MACROS_H */