kernel/TripletContainer.h

Go to the documentation of this file.

/**
 *  \file IMP/kernel/TripletContainer.h
 *  \brief A container for Triplets.
 *
 *  WARNING This file was generated from TripletContainer.h
 *  in /tmp/nightly-build-61576/imp-2.1.1/tools/build/container_templates/kernel
 *  by tools/maintenance/setup_containers.py.
 *
 *  Copyright 2007-2013 IMP Inventors. All rights reserved.
 */

#ifndef IMPKERNEL_DECLARE_TRIPLET_CONTAINER_H
#define IMPKERNEL_DECLARE_TRIPLET_CONTAINER_H

#include <IMP/kernel/kernel_config.h>
#include "internal/IndexingIterator.h"
#include "declare_Particle.h"
#include "container_base.h"
#include "internal/container_helpers.h"
#include "DerivativeAccumulator.h"
#include "ParticleTuple.h"
#include <IMP/base/ref_counted_macros.h>
#include <IMP/base/check_macros.h>
#include <IMP/base/Pointer.h>
#include <IMP/base/InputAdaptor.h>
#include <IMP/base/utility_macros.h>
#include <IMP/base/deprecation_macros.h>
#include <algorithm>

IMPKERNEL_BEGIN_NAMESPACE
class TripletModifier;
class TripletScore;

//! A shared container for Triplets
/** Stores a shared collection of Triplets.
 */
class IMPKERNELEXPORT TripletContainer : public Container {
 protected:
  TripletContainer(kernel::Model *m,
                     std::string name = "TripletContainer %1%");

 public:
  typedef ParticleTriplet ContainedType;
  typedef ParticleTripletsTemp ContainedTypes;
  typedef ParticleIndexTriplets ContainedIndexTypes;
  typedef ParticleIndexTriplet ContainedIndexType;

  //! Just use apply() in the base class
  void apply_generic(const TripletModifier *m) const;

  //! Apply a SingletonModifier to the contents
  void apply(const TripletModifier *sm) const;

  /** Get all the indexes contained in the container.*/
  virtual ParticleIndexTriplets get_indexes() const = 0;
  /** Get all the indexes that might possibly be contained in the
      container, useful with dynamic containers. For example,
      with a container::ClosePairContainer, this is the list
      of all pairs taken from input list (those that are far apart
      in addition to those that are close).
  */
  virtual ParticleIndexTriplets get_range_indexes() const = 0;

#ifndef IMP_DOXYGEN
  ParticleTripletsTemp get() const {
    return IMP::kernel::internal::get_particle(get_model(), get_indexes());
  }

  ParticleTriplet get(unsigned int i) const {
    return IMP::kernel::internal::get_particle(get_model(), get_indexes()[i]);
  }
  unsigned int get_number() const { return get_indexes().size(); }
#ifndef SWIG
  bool get_provides_access() const;
  virtual const ParticleIndexTriplets &get_access() const {
    IMP_THROW("Object not implemented properly.", base::IndexException);
  }

  template <class Functor> Functor for_each(Functor f) {
    ParticleIndexTriplets vs = get_indexes();
    // use boost range instead
    return std::for_each(vs.begin(), vs.end(), f);
  }

#endif
#endif

  /** \deprecated_at{2.1} Use get_indexes() instead.
   */
  ParticleTripletsTemp get_particle_triplets() const;

  /** \brief This function is very slow and you should think hard about using
      it.

      \deprecated_at{2.1} This is slow and dependent on the order of elements
      in the tuple.

      Return whether the container has the given element.*/
  IMPKERNEL_DEPRECATED_METHOD_DECL(2.1)
    bool get_contains_particle_triplet(ParticleTriplet v) const;

  /** \deprecated_at{2.1} This can be very slow and is probably not useful
   */
  IMPKERNEL_DEPRECATED_METHOD_DECL(2.1)
    unsigned int get_number_of_particle_triplets() const;

  /** \deprecated_at{2.1}Use get_indexes() instead and thing about using the
      IMP_CONTAINER_FOREACH() macro.*/
  IMPKERNEL_DEPRECATED_METHOD_DECL(2.1)
    ParticleTriplet get_particle_triplet(unsigned int i) const;

 protected:
  virtual void do_apply(const TripletModifier *sm) const = 0;
  virtual bool do_get_provides_access() const { return false; }

  IMP_REF_COUNTED_NONTRIVIAL_DESTRUCTOR(TripletContainer);
};

/** This class allows either a list or a container to be
    accepted as input.
*/
class IMPKERNELEXPORT TripletContainerAdaptor :
#if !defined(SWIG) && !defined(IMP_DOXYGEN)
    public base::Pointer<TripletContainer>
#else
    public base::InputAdaptor
#endif
    {
  typedef base::Pointer<TripletContainer> P;

 public:
  TripletContainerAdaptor() {}

  /**
     Constructs the adaptor pointing to c (so if the contents of c are changed
     dynamically, so do the contents of the adaptor, and vice versa)
   */
  TripletContainerAdaptor(TripletContainer *c);

  /**
     Constructs the adaptor pointing to c (so if the contents of c are changed
     dynamically, so do the contents of the adaptor, and vice versa)
   */
  template <class C>
  TripletContainerAdaptor(base::internal::PointerBase<C> c)
      : P(c) {}

  /**
     Adapts the non-empty list t to TripletContainer

     @param t a non-empty list of ParticleTripletsTemp
     @param name name for the constructed TripletContainer
  */
  TripletContainerAdaptor(const ParticleTripletsTemp &t,
                            std::string name = "TripletContainerAdaptor%1%");
};

IMPKERNEL_END_NAMESPACE

#endif /* IMPKERNEL_DECLARE_TRIPLET_CONTAINER_H */