IMP logo
IMP Reference Guide  develop.63b38c487d,2024/12/21
The Integrative Modeling Platform
version 20241221.develop.63b38c487d
decorator_macros.h
Go to the documentation of this file.
1 /**
2  * \file IMP/decorator_macros.h
3  * \brief Helper macros for implementing Decorators
4  *
5  * Copyright 2007-2022 IMP Inventors. All rights reserved.
6  *
7  */
8 
9 #ifndef IMPKERNEL_DECORATOR_MACROS_H
10 #define IMPKERNEL_DECORATOR_MACROS_H
11 #include <IMP/kernel_config.h>
12 #include "particle_index.h"
13 #include "Particle.h"
14 #include "Decorator.h"
15 #include <type_traits>
16 #include <IMP/check_macros.h>
17 #include <IMP/log_macros.h>
18 #include <IMP/showable_macros.h>
19 #include <IMP/warning_macros.h>
20 
21 /** Implement the needed methods for a decorator based on
22  - setup_particle()
23  - get_is_setup()
24  methods that you provide.
25 */
26 #define IMP_DECORATOR_METHODS(Name, Parent) \
27  public: \
28  /* Should be private but SWIG accesses it through the
29  comparison
30  macros*/ IMP_NO_DOXYGEN( \
31  typedef Parent ParentDecorator); \
32  Name() : Parent() {} \
33  Name(::IMP::Model *m, ::IMP::ParticleIndex id) \
34  : Parent(m, id) { \
35  IMP_INTERNAL_CHECK( \
36  get_is_setup(m, id), \
37  "Particle " << m->get_particle_name(id) \
38  << " missing required attributes for decorator " \
39  << #Name); \
40  } \
41  explicit Name(const IMP::ParticleAdaptor &d) : Parent(d) { \
42  IMP_INTERNAL_CHECK( \
43  get_is_setup(d.get_model(), d.get_particle_index()), \
44  "Particle " << d.get_model()->get_particle_name( \
45  d.get_particle_index()) \
46  << " missing required attributes for decorator " \
47  << #Name); \
48  } \
49  static bool get_is_setup(const IMP::ParticleAdaptor &p) { \
50  return get_is_setup(p.get_model(), p.get_particle_index()); \
51  } \
52  IMP_SHOWABLE(Name)
53 
54 
55 
56 /** Implement the needed methods for a decorator based on
57  - setup_particle()
58  - get_is_setup()
59  methods that you provide.
60 */
61 #define IMP_DECORATOR_WITH_TRAITS_METHODS(Name, Parent, TraitsType, \
62  traits_name, default_traits) \
63  private: \
64  TraitsType traits_; \
65  \
66  public: \
67  typedef TraitsType DecoratorTraits; \
68  const DecoratorTraits &get_decorator_traits() const { return traits_; } \
69  static const DecoratorTraits &get_default_decorator_traits() { \
70  static TraitsType dt = default_traits; \
71  return dt; \
72  } \
73  /* Should be private but SWIG accesses it through the
74  comparison
75  macros*/ IMP_NO_DOXYGEN( \
76  typedef Parent ParentDecorator); \
77  IMP_NO_DOXYGEN(typedef std::true_type DecoratorHasTraits); \
78  Name() : Parent() {} \
79  Name(::IMP::Model *m, ::IMP::ParticleIndex id, \
80  const TraitsType &tr = default_traits) \
81  : Parent(m, id), traits_(tr) { \
82  IMP_INTERNAL_CHECK( \
83  get_is_setup(m, id, tr), \
84  "Particle " << m->get_particle_name(id) \
85  << " missing required attributes for decorator " \
86  << #Name); \
87  } \
88  explicit Name(const IMP::ParticleAdaptor &d, \
89  const TraitsType &tr = default_traits) \
90  : Parent(d), traits_(tr) { \
91  IMP_INTERNAL_CHECK( \
92  get_is_setup(d.get_model(), d.get_particle_index(), tr), \
93  "Particle " << d.get_model()->get_particle_name( \
94  d.get_particle_index()) \
95  << " missing required attributes for decorator " \
96  << #Name); \
97  } \
98  static bool get_is_setup(const IMP::ParticleAdaptor &p, \
99  const TraitsType &tr = default_traits) { \
100  return get_is_setup(p.get_model(), p.get_particle_index(), tr); \
101  } \
102  IMP_SHOWABLE(Name)
103 
104 /** Decorators need to be able to be set up from Particles, ParticleIndexes
105  and other Decorators. To help keep things uniform, we provide macros
106  to declare the setup functions. These macros expect that an appropriate
107  `do_setup_particle(Model *, ParticleIndex, args...)` function is
108  defined.
109 */
110 #define IMP_DECORATOR_SETUP_0(Name) \
111  /**
112  @return a Name object that decorates particle pi
113  */ \
114  static Name setup_particle(Model *m, ParticleIndex pi) { \
115  IMP_USAGE_CHECK(!get_is_setup(m, pi), \
116  "Particle " << m->get_particle_name(pi) \
117  << " already set up as " << #Name); \
118  do_setup_particle(m, pi); \
119  return Name(m, pi); \
120  } \
121  /** @return a Name object that decorates the particle specified by pa
122  \see setup_particle(m, p) */ \
123  static Name setup_particle(IMP::ParticleAdaptor pa) { \
124  return setup_particle(pa.get_model(), \
125  pa.get_particle_index()); \
126  }
127 /** \see IMP_DECORATOR_SETUP_0() */
128 #define IMP_DECORATOR_SETUP_1(Name, FirstArgumentType, first_argument_name) \
129  /**
130  @return a Name object that decorates particle pi
131  */ \
132  static Name setup_particle(Model *m, ParticleIndex pi, \
133  FirstArgumentType first_argument_name) { \
134  IMP_USAGE_CHECK(!get_is_setup(m, pi), \
135  "Particle " << m->get_particle_name(pi) \
136  << " already set up as " << #Name); \
137  do_setup_particle(m, pi, first_argument_name); \
138  return Name(m, pi); \
139  } \
140  /** @return a Name object that decorates the particle specified by pa
141  \see setup_particle(m, pi, first_argument_name) */ \
142  static Name setup_particle(IMP::ParticleAdaptor pa, \
143  FirstArgumentType first_argument_name) { \
144  return setup_particle(pa.get_model(), \
145  pa.get_particle_index(), \
146  first_argument_name); \
147  }
148 
149 /** \see IMP_DECORATOR_SETUP_0() */
150 #define IMP_DECORATOR_SETUP_2(Name, FirstArgumentType, first_argument_name, \
151  SecondArgumentType, second_argument_name) \
152  /**
153  @return a Name object that decorates particle pi
154  */ \
155  static Name setup_particle(Model *m, ParticleIndex pi, \
156  FirstArgumentType first_argument_name, \
157  SecondArgumentType second_argument_name) { \
158  IMP_USAGE_CHECK(!get_is_setup(m, pi), \
159  "Particle " << m->get_particle_name(pi) \
160  << " already set up as " << #Name); \
161  do_setup_particle(m, pi, first_argument_name, second_argument_name); \
162  return Name(m, pi); \
163  } \
164  /** @return a Name object that decorates the particle specified by pa
165  \see setup_particle(m, p, first_argument_name, second_argument_name)
166  */ \
167  static Name setup_particle(IMP::ParticleAdaptor pa, \
168  FirstArgumentType first_argument_name, \
169  SecondArgumentType second_argument_name) { \
170  return setup_particle(pa.get_model(), \
171  pa.get_particle_index(), first_argument_name, \
172  second_argument_name); \
173  }
174 /** \see IMP_DECORATOR_SETUP_0() */
175 #define IMP_DECORATOR_SETUP_3(Name, FirstArgumentType, first_argument_name, \
176  SecondArgumentType, second_argument_name, \
177  ThirdArgumentType, third_argument_name) \
178  /**
179  @return a Name object that decorates particle pi
180  */ \
181  static Name setup_particle(Model *m, ParticleIndex pi, \
182  FirstArgumentType first_argument_name, \
183  SecondArgumentType second_argument_name, \
184  ThirdArgumentType third_argument_name) { \
185  IMP_USAGE_CHECK(!get_is_setup(m, pi), \
186  "Particle " << m->get_particle_name(pi) \
187  << " already set up as " << #Name); \
188  do_setup_particle(m, pi, first_argument_name, second_argument_name, \
189  third_argument_name); \
190  return Name(m, pi); \
191  } \
192  /** @return a Name object that decorates the particle specified by pa
193  \see setup_particle(m, pi, first_argument_name, second_argument_name,
194  third_argument_name) */ \
195  static Name setup_particle(IMP::ParticleAdaptor pa, \
196  FirstArgumentType first_argument_name, \
197  SecondArgumentType second_argument_name, \
198  ThirdArgumentType third_argument_name) { \
199  return setup_particle(pa.get_model(), \
200  pa.get_particle_index(), first_argument_name, \
201  second_argument_name, third_argument_name); \
202  }
203 /** \see IMP_DECORATOR_SETUP_0() */
204 #define IMP_DECORATOR_SETUP_4(Name, FirstArgumentType, first_argument_name, \
205  SecondArgumentType, second_argument_name, \
206  ThirdArgumentType, third_argument_name, \
207  FourthArgumentType, fourth_argument_name) \
208  /**
209  @return a Name object that decorates particle pi
210  */ \
211  static Name setup_particle(Model *m, ParticleIndex pi, \
212  FirstArgumentType first_argument_name, \
213  SecondArgumentType second_argument_name, \
214  ThirdArgumentType third_argument_name, \
215  FourthArgumentType fourth_argument_name) { \
216  IMP_USAGE_CHECK(!get_is_setup(m, pi), \
217  "Particle " << m->get_particle_name(pi) \
218  << " already set up as " << #Name); \
219  do_setup_particle(m, pi, first_argument_name, second_argument_name, \
220  third_argument_name, fourth_argument_name); \
221  return Name(m, pi); \
222  } \
223  /** @return a Name object that decorates the particle specified by pa
224  \see setup_particle(m, pi, first_argument_name, second_argument_name,
225  third_argument_name, fourth_argument_name) */ \
226  static Name setup_particle(IMP::ParticleAdaptor pa, \
227  FirstArgumentType first_argument_name, \
228  SecondArgumentType second_argument_name, \
229  ThirdArgumentType third_argument_name, \
230  FourthArgumentType fourth_argument_name) { \
231  return setup_particle(pa.get_model(), \
232  pa.get_particle_index(), first_argument_name, \
233  second_argument_name, third_argument_name, \
234  fourth_argument_name); \
235  }
236 
237 /** \see IMP_DECORATOR_SETUP_0() */
238 #define IMP_DECORATOR_SETUP_5(Name, \
239  FirstArgumentType, first_argument_name, \
240  SecondArgumentType, second_argument_name, \
241  ThirdArgumentType, third_argument_name, \
242  FourthArgumentType, fourth_argument_name, \
243  FifthArgumentType, fifth_argument_name) \
244  /**
245  @return a Name object that decorates particle pi
246  */ \
247  static Name setup_particle(Model *m, ParticleIndex pi, \
248  FirstArgumentType first_argument_name, \
249  SecondArgumentType second_argument_name, \
250  ThirdArgumentType third_argument_name, \
251  FourthArgumentType fourth_argument_name, \
252  FifthArgumentType fifth_argument_name) { \
253  IMP_USAGE_CHECK(!get_is_setup(m, pi), \
254  "Particle " << m->get_particle_name(pi) \
255  << " already set up as " << #Name); \
256  do_setup_particle(m, pi, first_argument_name, second_argument_name, \
257  third_argument_name, fourth_argument_name, \
258  fifth_argument_name); \
259  return Name(m, pi); \
260  } \
261  /** @return a Name object that decorates the particle specified by pa
262  \see setup_particle(m, pi, first_argument_name, second_argument_name,
263  third_argument_name, fourth_argument_name, fifth_argument_name) */ \
264  static Name setup_particle(IMP::ParticleAdaptor pa, \
265  FirstArgumentType first_argument_name, \
266  SecondArgumentType second_argument_name, \
267  ThirdArgumentType third_argument_name, \
268  FourthArgumentType fourth_argument_name, \
269  FifthArgumentType fifth_argument_name) { \
270  return setup_particle(pa.get_model(), \
271  pa.get_particle_index(), first_argument_name, \
272  second_argument_name, third_argument_name, \
273  fourth_argument_name, fifth_argument_name); \
274  }
275 
276 /** Decorators need to be able to be set up from Particles, ParticleIndexes
277  and other Decorators. To help keep things uniform, we provide macros
278  to declare the setup functions. These macros expect that an appropriate
279  `do_setup_particle(Model *, ParticleIndex, args...)` function is
280  defined. But any docs needed before the macro invocation.
281 */
282 #define IMP_DECORATOR_TRAITS_SETUP_0(Name) \
283  /**
284  @return a Name object that decorates particle pi
285  */ \
286  static Name setup_particle( \
287  Model *m, ParticleIndex pi, \
288  DecoratorTraits tr = get_default_decorator_traits()) { \
289  do_setup_particle(m, pi, tr); \
290  return Name(m, pi, tr); \
291  } \
292  static Name setup_particle( \
293  IMP::ParticleAdaptor d, \
294  DecoratorTraits tr = get_default_decorator_traits()) { \
295  do_setup_particle(d.get_model(), d.get_particle_index(), tr); \
296  return Name(d.get_model(), d.get_particle_index(), tr); \
297  }
298 /** \see IMP_DECORATOR_TRAITS_SETUP_0() */
299 #define IMP_DECORATOR_TRAITS_SETUP_1(Name, FirstArgumentType, \
300  first_argument_name) \
301  static Name setup_particle( \
302  Model *m, ParticleIndex pi, \
303  FirstArgumentType first_argument_name, \
304  DecoratorTraits tr = get_default_decorator_traits()) { \
305  do_setup_particle(m, pi, first_argument_name, tr); \
306  return Name(m, pi, tr); \
307  } \
308  static Name setup_particle( \
309  IMP::ParticleAdaptor d, FirstArgumentType first_argument_name, \
310  DecoratorTraits tr = get_default_decorator_traits()) { \
311  do_setup_particle(d.get_model(), d.get_particle_index(), \
312  first_argument_name, tr); \
313  return Name(d.get_model(), d.get_particle_index(), tr); \
314  }
315 /** \see IMP_DECORATOR_TRAITS_SETUP_0() */
316 #define IMP_DECORATOR_TRAITS_SETUP_2(Name, FirstArgumentType, \
317  first_argument_name, SecondArgumentType, \
318  second_argument_name) \
319  static Name setup_particle( \
320  Model *m, ParticleIndex pi, \
321  FirstArgumentType first_argument_name, \
322  SecondArgumentType second_argument_name, \
323  DecoratorTraits tr = get_default_decorator_traits()) { \
324  do_setup_particle(m, pi, first_argument_name, second_argument_name, tr); \
325  return Name(m, pi, tr); \
326  } \
327  static Name setup_particle( \
328  IMP::ParticleAdaptor d, FirstArgumentType first_argument_name, \
329  SecondArgumentType second_argument_name, \
330  DecoratorTraits tr = get_default_decorator_traits()) { \
331  do_setup_particle(d.get_model(), d.get_particle_index(), \
332  first_argument_name, second_argument_name, tr); \
333  return Name(d.get_model(), d.get_particle_index(), tr); \
334  }
335 
336 //! Perform actions dependent on whether a particle has an attribute.
337 /** A common pattern is to check if a particle has a particular attribute,
338  do one thing if it does and another if it does not. This macro implements
339  that pattern. It requires that the method get_particle_index() return the
340  particle being used.
341 
342  \param[in] AttributeKey The key for the attribute
343  \param[in] Type The type for the attribute ("Int", "Float", "String")
344  \param[in] has_action The action to take if the Particle has the attribute.
345  The attribute value is stored in the variable VALUE.
346  \param[in] not_has_action The action to take if the Particle does not have
347  the attribute.
348  \see IMP_DECORATOR_GET()
349  \see IMP_DECORATOR_GET_SET()
350 
351 */
352 #define IMP_DECORATOR_GET(AttributeKey, Type, has_action, not_has_action) \
353  do { \
354  if (get_model()->get_has_attribute(AttributeKey, get_particle_index())) { \
355  Type VALUE = \
356  get_model()->get_attribute(AttributeKey, get_particle_index()); \
357  has_action; \
358  } else { \
359  not_has_action; \
360  } \
361  } while (false)
362 
363 //! Set an attribute, creating it if it does not already exist.
364 /** Another common pattern is to have an assumed value if the attribute
365  is not there. Then, you sometimes need to set the value whether it
366  is there or not.
367  \see IMP_DECORATOR_GET()
368  \see IMP_DECORATOR_GET_SET()
369 */
370 #define IMP_DECORATOR_SET(AttributeKey, value) \
371  do { \
372  if (get_model()->get_has_attribute(AttributeKey, get_particle_index())) { \
373  get_model()->set_attribute(AttributeKey, get_particle_index(), value); \
374  } else { \
375  get_model()->add_attribute(AttributeKey, get_particle_index(), value); \
376  } \
377  } while (false)
378 
379 //! Define methods for getting and setting a particular simple field
380 /** This macro defines methods to get and set a particular attribute.
381 
382  \param[in] name The lower case name of the attribute
383  \param[in] AttributeKey The AttributeKey object controlling
384  the attribute.
385  \param[in] Type The type of the attribute (upper case).
386  \param[in] ReturnType The type to return from the get.
387  \see IMP_DECORATOR_GET()
388  \see IMP_DECORATOR_SET()
389 */
390 #define IMP_DECORATOR_GET_SET(name, AttributeKey, Type, ReturnType) \
391  /** returns the value of the name attribute */ \
392  ReturnType get_##name() const { \
393  return static_cast<ReturnType> \
394  (get_model()->get_attribute(AttributeKey, get_particle_index())); \
395  } \
396  /** sets the value of the name attribute to t */ \
397  void set_##name(ReturnType t) { \
398  get_model()->set_attribute(AttributeKey, get_particle_index(), t); \
399  } \
400  IMP_REQUIRE_SEMICOLON_CLASS(getset##name)
401 
402 //! Define methods for getting and setting an optional simple field.
403 /** See IMP_DECORATOR_GET_SET(). The difference is that here you can provide
404  a default value to use if the decorator does not have the attribute.
405 
406  \param[in] name The lower case name of the attribute
407  \param[in] AttributeKey The expression to get the required attribute key.
408  \param[in] Type The type of the attribute (upper case).
409  \param[in] ReturnType The type to return from the get.
410  \param[in] default_value The value returned if the attribute is missing.
411 */
412 #define IMP_DECORATOR_GET_SET_OPT(name, AttributeKey, Type, ReturnType, \
413  default_value) \
414  /** returns the value of the name attribute, or default_value if \
415  the name attribute is missing */ \
416  ReturnType get_##name() const { \
417  IMP_DECORATOR_GET(AttributeKey, Type, \
418  return static_cast<ReturnType>(VALUE), \
419  return default_value); \
420  } \
421  /** sets the name attribute to t */ \
422  void set_##name(ReturnType t) { IMP_DECORATOR_SET(AttributeKey, t); } \
423  IMP_REQUIRE_SEMICOLON_CLASS(getset_##name)
424 
425 #define IMP_DECORATORS_DECL(Name, PluralName) \
426  class Name; \
427  typedef IMP::Vector<Name> PluralName
428 
429 #ifndef IMP_DOXYGEN
430 #define IMP_DECORATORS_DEF(Name, PluralName) \
431  /* needed so there is no ambiguity with operator->*/ \
432  inline std::ostream &operator<<(std::ostream &out, Name n) { \
433  n.show(out); \
434  return out; \
435  }
436 #else
437 #define IMP_DECORATORS_DEF(Name, PluralName)
438 #endif
439 
440 //! Define the types for storing sets of decorators
441 /** The macro defines the types PluralName and PluralNameTemp.
442  Parent is unused and remains for backward compatibility
443  */
444 #define IMP_DECORATORS(Name, PluralName, Parent) \
445  IMP_DECORATORS_DECL(Name, PluralName); \
446  IMP_DECORATORS_DEF(Name, PluralName)
447 
448 //! Define the types for storing sets of decorators
449 /** The macro defines the types PluralName and PluralNameTemp.
450  */
451 #define IMP_DECORATORS_WITH_TRAITS(Name, PluralName, Parent) \
452  /* needed so there is no ambiguity with operator->*/ \
453  inline std::ostream &operator<<(std::ostream &out, Name n) { \
454  n.show(out); \
455  return out; \
456  } \
457  typedef IMP::Vector<Name> PluralName
458 
459 
460 /**
461  Declares Decorator methods that allows (privately) setting a constraint
462  and publicly getting that constraint
463  */
464 #define IMP_CONSTRAINT_DECORATOR_DECL(Name) \
465  private: \
466  static ObjectKey get_constraint_key(); \
467  /** set a constraint associated with this decorator that applies 'before'
468  and 'after' before and after evaluation. The constraint is added as
469  a model ScoreState. If before and after are Null, the constraint is
470  reset and removed from the model list of score states.
471  */ \
472  static void set_constraint(SingletonModifier* before, \
473  SingletonDerivativeModifier* after, Model* m, \
474  ParticleIndex pi); \
475  \
476  public: \
477  Constraint* get_constraint() const { \
478  return dynamic_cast<Constraint*>( \
479  get_particle()->get_value(get_constraint_key())); \
480  } \
481  IMP_REQUIRE_SEMICOLON_CLASS(constraint)
482 
483 /**
484  Defines Decorator methods that allows (privately) setting a constraint
485  and publicly getting that constraint. The constraint is added as a
486  score state to the model.
487  */
488 #define IMP_CONSTRAINT_DECORATOR_DEF(Name, can_skip) \
489  ObjectKey Name::get_constraint_key() { \
490  static ObjectKey ret(#Name " score state"); \
491  return ret; \
492  } \
493  void Name::set_constraint(SingletonModifier* before, \
494  SingletonDerivativeModifier* after, Model* m, \
495  ParticleIndex pi) { \
496  if (!after && !before) { \
497  if (m->get_has_attribute(get_constraint_key(), pi)) { \
498  m->remove_score_state(dynamic_cast<ScoreState*>( \
499  m->get_attribute(get_constraint_key(), pi))); \
500  m->remove_attribute(get_constraint_key(), pi); \
501  } \
502  } else { \
503  Constraint* ss = new core::SingletonConstraint( \
504  before, after, m, pi, \
505  std::string(#Name "updater for ") + m->get_particle_name(pi), \
506  can_skip); \
507  m->add_attribute(get_constraint_key(), pi, ss); \
508  m->add_score_state(ss); \
509  } \
510  } \
511  IMP_REQUIRE_SEMICOLON_NAMESPACE
512 
513 
514 /** Register a function that can be used to check that the particle
515  is valid with respect to the decorator. The function should take
516  a Particle* as an argument and return a bool. It should throw
517  an exception if something is wrong.
518 
519  This macro should only be used in a .cpp file.
520 */
521 #define IMP_CHECK_DECORATOR(Name, function) \
522  IMP::internal::ParticleCheck Name##pc(Name::get_is_setup, function);
523 
524 
525 //! Create a decorator that computes some sort of summary info on a set
526 /** Examples include a centroid or a cover for a set of particles.
527 
528  \param[in] Name The name for the decorator
529  \param[in] Parent the parent decorator type
530  \param[in] Members the way to pass a set of particles in
531  \param[in] SetupDoc extra documentation for setup
532 */
533 #define IMP_SUMMARIZE_DECORATOR_DECL(Name, Parent, Members, SetupDoc) \
534  class IMPCOREEXPORT Name : public Parent { \
535  IMP_CONSTRAINT_DECORATOR_DECL(Name); \
536  private: \
537  /** Sets up Name over particles in pis */ \
538  static void do_setup_particle(Model *m, ParticleIndex pi, \
539  const ParticleIndexes &pis); \
540  /** Sets up Name over particles passed by applying the refiner
541  over the particle pi
542  */ \
543  static void do_setup_particle(Model *m, ParticleIndex pi, \
544  Refiner *ref); \
545  \
546  public: \
547  IMP_DECORATOR_METHODS(Name, Parent); \
548  /** Sets up Name over members, and constrains Name to be
549  computed before model evaluation and to propagate derivatives
550  following model evaluation.
551  SetupDoc
552  */ \
553  IMP_DECORATOR_SETUP_1(Name, ParticleIndexesAdaptor, members); \
554  /** Sets up Name over particles passed by applying the refiner
555  over the particle pi, and constrains Name to be computed before
556  model evaluation and to propagate derivatives following model
557  evaluation.
558  SetupDoc
559  */ \
560  IMP_DECORATOR_SETUP_1(Name, Refiner *, refiner); \
561  static bool get_is_setup(Model *m, ParticleIndex pi) { \
562  return m->get_has_attribute(get_constraint_key(), pi); \
563  } \
564  IMP_NO_DOXYGEN(typedef std::false_type DecoratorHasTraits); \
565  \
566  private: \
567  /* hide set methods*/ \
568  void set_coordinates() {}; \
569  void set_coordinates_are_optimized() const {} \
570  void set_coordinate() const {} \
571  void set_radius() const {} \
572  }; \
573  IMP_DECORATORS(Name, Name##s, Parent##s)
574 
575 
576 /** \see IMP_SUMMARIZE_DECORATOR_DECL()
577  \param[in] Name The name for the decorator
578  \param[in] Parent the parent decorator type
579  \param[in] Members the way to pass a set of particles in
580  \param[in] create_pre_modifier the statements to create the
581  SingletonModifier which computes the summary info,
582  using refiner 'ref'
583  \param[in] create_post_modifier a SingletonDerivativeModifier for
584  the derivatives of the summary back to its members,
585  using refiner 'ref'
586  \param[in] can_skip set to true iff the modifiers do not need to be
587  called when the particle did not move
588 */
589 #define IMP_SUMMARIZE_DECORATOR_DEF(Name, Parent, Members, \
590  create_pre_modifier, \
591  create_post_modifier, can_skip) \
592  void Name::do_setup_particle(Model *m, ParticleIndex pi, \
593  const ParticleIndexes &pis) { \
594  Refiner *ref = new FixedRefiner(IMP::get_particles(m, pis)); \
595  SingletonModifier* pre_mod = create_pre_modifier; \
596  SingletonDerivativeModifier* post_mod = create_post_modifier; \
597  if (!Parent::get_is_setup(m, pi)) Parent::setup_particle(m, pi); \
598  set_constraint(pre_mod, post_mod, m, pi); \
599  } \
600  \
601  void Name::do_setup_particle(Model *m, ParticleIndex pi, \
602  Refiner *ref) { \
603  SingletonModifier* pre_mod = create_pre_modifier; \
604  SingletonDerivativeModifier* post_mod = create_post_modifier; \
605  if (!Parent::get_is_setup(m, pi)) Parent::setup_particle(m, pi); \
606  set_constraint(pre_mod, post_mod, m, pi); \
607  } \
608  \
609  void Name::show(std::ostream &out) const { \
610  out << #Name << " at " << static_cast<Parent>(*this); \
611  } \
612  IMP_CONSTRAINT_DECORATOR_DEF(Name, can_skip)
613 
614 #endif /* IMPKERNEL_DECORATOR_MACROS_H */
Decorator.h
The base class for decorators.
particle_index.h
Functions and adaptors for dealing with particle indexes.
warning_macros.h
Macros to control compiler warnings.
log_macros.h
Logging and error reporting support.
Particle.h
Classes to handle individual model particles. (Note that implementation of inline functions is in int...
check_macros.h
Helper macros for throwing and handling exceptions.
showable_macros.h
Macros to help with objects that can be printed to a stream.