singleton_predicates.h

Go to the documentation of this file.

// Autogenerated by ../../../../tmp/nightly-build-472/imp-20241121.develop.d97d4ead1f/tools/build/make_containers.py
// from ../../../../tmp/nightly-build-472/imp-20241121.develop.d97d4ead1f/tools/build/container_templates/core/classname_predicates.h
// Do not edit - any changes will be lost!

/**
 *  \file IMP/core/singleton_predicates.h
 *  \brief Define some predicates.
 *
 *  Copyright 2007-2023 IMP Inventors. All rights reserved.
 */

#ifndef IMPCORE_SINGLETON_PREDICATES_H
#define IMPCORE_SINGLETON_PREDICATES_H

#include <IMP/core/core_config.h>
#include <IMP/core/Typed.h>
#include <IMP/SingletonPredicate.h>
#include <IMP/singleton_macros.h>
#include <boost/random.hpp>
#include "internal/container_helpers.h"
#include <cereal/access.hpp>
#include <cereal/types/base_class.hpp>

IMPCORE_BEGIN_NAMESPACE

//! Always return a constant value.
class IMPCOREEXPORT ConstantSingletonPredicate : public SingletonPredicate {
  int v_;

  friend class cereal::access;
  template<class Archive> void serialize(Archive &ar) {
    ar(cereal::base_class<SingletonPredicate>(this), v_);
  }
  IMP_OBJECT_SERIALIZE_DECL(ConstantSingletonPredicate);

 public:
  ConstantSingletonPredicate(int v,
                             std::string name = "ConstSingletonPredicate%1%");

  ConstantSingletonPredicate() {}

  virtual int get_value_index(Model *, ParticleIndex) const
      override {
    return v_;
  }
  virtual ModelObjectsTemp do_get_inputs(
      Model *, const ParticleIndexes &) const override {
    return ModelObjectsTemp();
  }
  IMP_SINGLETON_PREDICATE_METHODS(ConstantSingletonPredicate);
  IMP_OBJECT_METHODS(ConstantSingletonPredicate);
};

//! Return a unique predicate value for each unordered set of ParticleTypes
/** When applied to a set of particles that are decorated with the
    Typed decorator, this returns a value that is a function of all of
    the types. The order of the particles does not matter.
 */
class IMPCOREEXPORT UnorderedTypeSingletonPredicate
    : public SingletonPredicate {
  friend class cereal::access;
  template<class Archive> void serialize(Archive &ar) {
    ar(cereal::base_class<SingletonPredicate>(this));
  }
  IMP_OBJECT_SERIALIZE_DECL(UnorderedTypeSingletonPredicate);

 public:
  UnorderedTypeSingletonPredicate(std::string name =
                                      "UnorderedTypeSingletonPredicate%1%");
  virtual int get_value_index(Model *m, ParticleIndex pi) const
      override {
    return internal::get_type_hash(m, pi);
  }
  virtual ModelObjectsTemp do_get_inputs(
      Model *m, const ParticleIndexes &pis) const override {
    ModelObjectsTemp ret;
    ret += IMP::get_particles(m, pis);
    return ret;
  }
  IMP_SINGLETON_PREDICATE_METHODS(UnorderedTypeSingletonPredicate);
  IMP_OBJECT_METHODS(UnorderedTypeSingletonPredicate);
};

//! Return a unique predicate value for each ordered set of ParticleTypes
/** When applied to a set of particles that are decorated with the
    Typed decorator, this returns a value that is a function of all of
    the types. The order of the particles matters.
 */
class IMPCOREEXPORT OrderedTypeSingletonPredicate : public SingletonPredicate {
 private:
  mutable int const* cached_particle_type_ids_table_;
  mutable int cached_n_particle_types_;
 public:
  OrderedTypeSingletonPredicate(std::string name =
                                    "OrderedTypeSingletonPredicate%1%");
  //! Compute the predicate for specified types
  int get_value(const core::ParticleTypes &types) {
    return internal::get_ordered_type_hash(types);
  }
  //! Compute the predicate for types of specific pi
  virtual int get_value_index(Model *m, ParticleIndex pi) const
      override {
    return internal::get_ordered_type_hash(m, pi);
  }

  //! Setup for a batch of calls to get_value_index_in_batch()
  //! (used for improving performance)
  virtual void setup_for_get_value_index_in_batch(Model* m) const
  override{
    cached_particle_type_ids_table_=
      m->IMP::internal::IntAttributeTable::access_attribute_data(Typed::get_type_key());
    cached_n_particle_types_= ParticleType::get_number_unique();
  };

  //! Same as get_value_index, but with optimizations
  //! for a batch of calls. Call setup_for_get_value_index_in_batch()
  //! right before calling a batch of those, otherwise unexpected behavior.
  virtual int get_value_index_in_batch(Model* m, ParticleIndex pi) const
  override{
    IMP_UNUSED(m);
    return internal::get_ordered_type_hash( pi,
                                            cached_particle_type_ids_table_,
                                            cached_n_particle_types_);
  }

  virtual ModelObjectsTemp do_get_inputs(
      Model *m, const ParticleIndexes &pis) const override {
    ModelObjectsTemp ret;
    ret += IMP::get_particles(m, pis);
    return ret;
  }
  IMP_SINGLETON_PREDICATE_METHODS(OrderedTypeSingletonPredicate);
  IMP_OBJECT_METHODS(OrderedTypeSingletonPredicate);
};

//! Return true (1) if all members of the tuple are the same.
class IMPCOREEXPORT AllSameSingletonPredicate : public SingletonPredicate {
  friend class cereal::access;
  template<class Archive> void serialize(Archive &ar) {
    ar(cereal::base_class<SingletonPredicate>(this));
  }
  IMP_OBJECT_SERIALIZE_DECL(AllSameSingletonPredicate);

 public:
  AllSameSingletonPredicate(std::string name = "AllSameSingletonPredicate%1%");
  virtual int get_value_index(Model *m, ParticleIndex pi) const
      override {
    return internal::get_all_same(m, pi);
  }
  virtual ModelObjectsTemp do_get_inputs(
      Model *, const ParticleIndexes &) const override {
    return ModelObjectsTemp();
  }
  IMP_SINGLETON_PREDICATE_METHODS(AllSameSingletonPredicate);
  IMP_OBJECT_METHODS(AllSameSingletonPredicate);
};

//! Return true (1) with a fixed probability.
class IMPCOREEXPORT CoinFlipSingletonPredicate : public SingletonPredicate {
  double p_;
  mutable boost::random::uniform_real_distribution<double> rng_;

 public:
  CoinFlipSingletonPredicate(double p, std::string name =
                                           "CoinFlipSingletonPredicate%1%");
  virtual int get_value_index(Model *, ParticleIndex) const
      override {
    if (rng_(random_number_generator) < p_)
      return 1;
    else
      return 0;
  }
  virtual ModelObjectsTemp do_get_inputs(
      Model *, const ParticleIndexes &) const override {
    return ModelObjectsTemp();
  }
  IMP_SINGLETON_PREDICATE_METHODS(CoinFlipSingletonPredicate);
  IMP_OBJECT_METHODS(CoinFlipSingletonPredicate);
};

IMPCORE_END_NAMESPACE

#endif /* IMPCORE_SINGLETON_PREDICATES_H */