Changeset 4272f0 for molecuilder/src

Timestamp:

Feb 2, 2010, 4:46:29 PM (16 years ago)

Author:

Tillmann Crueger <crueger@…>

Children:

bb9503

Parents:

8fc9b6

Message:

Added possibility to disable caching mechanism at compile time

Location:

molecuilder/src

Files:

• Makefile.am (modified) (1 diff)
• Patterns/Cacheable.hpp (modified) (1 diff)

molecuilder/src/Makefile.am

@@ -32 +32 @@
 bin_PROGRAMS = molecuilder joiner analyzer
 molecuilderdir = ${bindir}
+#libmolecuilder_a_CXXFLAGS = -DNO_CACHING
 libmolecuilder_a_SOURCES = ${SOURCE} ${HEADER}
 libgslwrapper_a_SOURCES = ${LINALGSOURCE} ${LINALGHEADER}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
 molecuilder_LDFLAGS = $(BOOST_LIB)
+#molecuilder_CXXFLAGS = -DNO_CACHING
 molecuilder_SOURCES = builder.cpp
 molecuilder_LDADD = libmolecuilder.a libgslwrapper.a

molecuilder/src/Patterns/Cacheable.hpp

@@ -12 +12 @@
 #include <boost/function.hpp>
 
-template<typename T>
-class Cacheable : public Observer
-{
-public:
-  Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
-  virtual ~Cacheable();
+#ifndef NO_CACHING
 
-  const bool isValid();
-  const T& operator*();
-  const bool operator==(const T&);
-  const bool operator!=(const T&);
+  template<typename T>
+  class Cacheable : public Observer
+  {
+  public:
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    virtual ~Cacheable();
 
-  // methods implemented for base-class Observer
-  void update(Observable *subject);
-  void subjectKilled(Observable *subject);
-private:
-  void checkValid();
+    const bool isValid();
+    const T& operator*();
+    const bool operator==(const T&);
+    const bool operator!=(const T&);
 
-  T content;
-  Observable *owner;
-  bool valid;
-  bool canBeUsed;
-  boost::function<T()> recalcMethod;
-};
+    // methods implemented for base-class Observer
+    void update(Observable *subject);
+    void subjectKilled(Observable *subject);
+  private:
+    void checkValid();
 
-template<typename T>
-Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
-  owner(_owner),
-  recalcMethod(_recalcMethod),
-  valid(false),
-  canBeUsed(true)
-{
-  owner->signOn(this);
-}
+    T content;
+    Observable *owner;
+    bool valid;
+    bool canBeUsed;
+    boost::function<T()> recalcMethod;
+  };
 
-template<typename T>
-const T& Cacheable<T>::operator*(){
-  checkValid();
-  return content;
-}
 
-template<typename T>
-const bool Cacheable<T>::operator==(const T& rval){
-  checkValid();
-  return (content == rval);
-}
+  template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+    owner(_owner),
+    recalcMethod(_recalcMethod),
+    valid(false),
+    canBeUsed(true)
+  {
+    owner->signOn(this);
+  }
 
-template<typename T>
-const bool Cacheable<T>::operator!=(const T& rval){
-  checkValid();
-  return (content != rval);
-}
+  template<typename T>
+  const T& Cacheable<T>::operator*(){
+    checkValid();
+    return content;
+  }
 
-template<typename T>
-Cacheable<T>::~Cacheable()
-{
-  owner->signOff(this);
-}
+  template<typename T>
+  const bool Cacheable<T>::operator==(const T& rval){
+    checkValid();
+    return (content == rval);
+  }
 
-template<typename T>
-const bool Cacheable<T>::isValid(){
-  return valid;
-}
+  template<typename T>
+  const bool Cacheable<T>::operator!=(const T& rval){
+    checkValid();
+    return (content != rval);
+  }
 
-template<typename T>
-void Cacheable<T>::update(Observable *subject) {
-  valid = false;
-}
+  template<typename T>
+  Cacheable<T>::~Cacheable()
+  {
+    owner->signOff(this);
+  }
 
-template<typename T>
-void Cacheable<T>::subjectKilled(Observable *subject) {
-  valid = false;
-  canBeUsed = false;
-}
+  template<typename T>
+  const bool Cacheable<T>::isValid(){
+    return valid;
+  }
 
-template<typename T>
-void Cacheable<T>::checkValid(){
-  assert(canBeUsed && "Cacheable used after owner was deleted");
-  if(!isValid()){
-    content = recalcMethod();
+  template<typename T>
+  void Cacheable<T>::update(Observable *subject) {
+    valid = false;
   }
-}
+
+  template<typename T>
+  void Cacheable<T>::subjectKilled(Observable *subject) {
+    valid = false;
+    canBeUsed = false;
+  }
+
+  template<typename T>
+  void Cacheable<T>::checkValid(){
+    assert(canBeUsed && "Cacheable used after owner was deleted");
+    if(!isValid()){
+      content = recalcMethod();
+    }
+  }
+#else
+  template<typename T>
+  class Cacheable : public Observer
+  {
+  public:
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    virtual ~Cacheable();
+
+    const bool isValid();
+    const T& operator*();
+    const bool operator==(const T&);
+    const bool operator!=(const T&);
+
+    // methods implemented for base-class Observer
+    void update(Observable *subject);
+    void subjectKilled(Observable *subject);
+  private:
+
+    boost::function<T()> recalcMethod;
+  };
+
+  template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+    recalcMethod(_recalcMethod)
+  {}
+
+  template<typename T>
+  const T& Cacheable<T>::operator*(){
+    return recalcMethod();
+  }
+
+  template<typename T>
+  const bool Cacheable<T>::operator==(const T& rval){
+    return (recalcMethod() == rval);
+  }
+
+  template<typename T>
+  const bool Cacheable<T>::operator!=(const T& rval){
+    return (recalcMethod() != rval);
+  }
+
+  template<typename T>
+  Cacheable<T>::~Cacheable()
+  {}
+
+  template<typename T>
+  const bool Cacheable<T>::isValid(){
+    return true;
+  }
+
+  template<typename T>
+  void Cacheable<T>::update(Observable *subject) {
+    assert(0 && "Cacheable::update should never be called when caching is disabled");
+  }
+
+  template<typename T>
+  void Cacheable<T>::subjectKilled(Observable *subject) {
+    assert(0 && "Cacheable::subjectKilled should never be called when caching is disabled");
+  }
+#endif
 
 #endif /* CACHEABLE_HPP_ */