kernel/generic.h

Go to the documentation of this file.

/**
 *  \file IMP/kernel/generic.h    \brief Various important functionality
 *                                       for implementing decorators.
 *
 *  Copyright 2007-2013 IMP Inventors. All rights reserved.
 *
 */

#ifndef IMPKERNEL_GENERIC_H
#define IMPKERNEL_GENERIC_H

#include <IMP/kernel/kernel_config.h>
#include "internal/scoring_functions.h"
#include "internal/TupleRestraint.h"
#include "internal/TupleConstraint.h"

IMPKERNEL_BEGIN_NAMESPACE

/** Create a ScoringFunction on a single restraints. This can be faster than
    using a RestraintsScoringFunction.*/
template <class RestraintType>
inline ScoringFunction *create_scoring_function(RestraintType *rs,
                                                double weight = 1.0,
                                                double max = NO_MAX,
                                                std::string name =
                                                    std::string()) {
  return internal::create_scoring_function(rs, weight, max, name);
}

/** When programming in C++, you can use generic restraint instead
    of a SingletonRestraint, PairRestraint, etc. The result is
    somewhat faster (20% or so).
*/
template <class Score>
inline Restraint *create_restraint(Score *s, const typename Score::Argument &t,
                                   std::string name = std::string()) {
  return internal::create_tuple_restraint(
      s, IMP::kernel::internal::get_model(t),
      IMP::kernel::internal::get_index(t), name);
}

template <class Score>
inline Restraint *create_restraint(const Score *s,
                                   const typename Score::Argument &t,
                                   std::string name = std::string()) {
  return internal::create_tuple_restraint(
      const_cast<Score *>(s), IMP::kernel::internal::get_model(t),
      IMP::kernel::internal::get_index(t), name);
}

/** When programming in C++, you can use generic constraint instead
    of a SingletonConstraint, PairConstraint, etc. The result is
    somewhat faster (20% or so).
*/
template <class Before, class After>
inline Constraint *create_constraint(Before *b, After *a,
                                     const typename Before::Argument &t,
                                     std::string name = std::string()) {
  return internal::create_tuple_constraint(b, a, t, name);
}

IMPKERNEL_END_NAMESPACE

#endif /* IMPKERNEL_GENERIC_H */