add a .clang-format file (#9154)

src/Observer.h

@@ -8,99 +8,90 @@ template <class T> class Observable;
 /**
  * An observer which can be mixed in as a baseclass.  Implement onNotify as a method in your class.
  */
-template <class T> class Observer
-{
-    std::list<Observable<T> *> observables;
+template <class T> class Observer {
+  std::list<Observable<T> *> observables;
 
-  public:
-    virtual ~Observer();
+public:
+  virtual ~Observer();
 
-    /// Stop watching the observable
-    void unobserve(Observable<T> *o);
+  /// Stop watching the observable
+  void unobserve(Observable<T> *o);
 
-    /// Start watching a specified observable
-    void observe(Observable<T> *o);
+  /// Start watching a specified observable
+  void observe(Observable<T> *o);
 
-  private:
-    friend class Observable<T>;
+private:
+  friend class Observable<T>;
 
-  protected:
-    /**
-     * returns 0 if other observers should continue to be called
-     * returns !0 if the observe calls should be aborted and this result code returned for notifyObservers
-     **/
-    virtual int onNotify(T arg) = 0;
+protected:
+  /**
+   * returns 0 if other observers should continue to be called
+   * returns !0 if the observe calls should be aborted and this result code returned for notifyObservers
+   **/
+  virtual int onNotify(T arg) = 0;
 };
 
 /**
  * An observer that calls an arbitrary method
  */
-template <class Callback, class T> class CallbackObserver : public Observer<T>
-{
-    typedef int (Callback::*ObserverCallback)(T arg);
+template <class Callback, class T> class CallbackObserver : public Observer<T> {
+  typedef int (Callback::*ObserverCallback)(T arg);
 
-    Callback *objPtr;
-    ObserverCallback method;
+  Callback *objPtr;
+  ObserverCallback method;
 
-  public:
-    CallbackObserver(Callback *_objPtr, ObserverCallback _method) : objPtr(_objPtr), method(_method) {}
+public:
+  CallbackObserver(Callback *_objPtr, ObserverCallback _method) : objPtr(_objPtr), method(_method) {}
 
-  protected:
-    virtual int onNotify(T arg) override { return (objPtr->*method)(arg); }
+protected:
+  virtual int onNotify(T arg) override { return (objPtr->*method)(arg); }
 };
 
 /**
- * An observable class that will notify observers anytime notifyObservers is called.  Argument type T can be any type, but for
- * performance reasons a pointer or word sized object is recommended.
+ * An observable class that will notify observers anytime notifyObservers is called.  Argument type T can be any type,
+ * but for performance reasons a pointer or word sized object is recommended.
  */
-template <class T> class Observable
-{
-    std::list<Observer<T> *> observers;
+template <class T> class Observable {
+  std::list<Observer<T> *> observers;
 
-  public:
-    /**
-     * Tell all observers about a change, observers can process arg as they wish
-     *
-     * returns !0 if an observer chose to abort processing by returning this code
-     */
-    int notifyObservers(T arg)
-    {
-        for (typename std::list<Observer<T> *>::const_iterator iterator = observers.begin(); iterator != observers.end();
-             ++iterator) {
-            int result = (*iterator)->onNotify(arg);
-            if (result != 0)
-                return result;
-        }
-
-        return 0;
+public:
+  /**
+   * Tell all observers about a change, observers can process arg as they wish
+   *
+   * returns !0 if an observer chose to abort processing by returning this code
+   */
+  int notifyObservers(T arg) {
+    for (typename std::list<Observer<T> *>::const_iterator iterator = observers.begin(); iterator != observers.end(); ++iterator) {
+      int result = (*iterator)->onNotify(arg);
+      if (result != 0)
+        return result;
     }
 
-  private:
-    friend class Observer<T>;
+    return 0;
+  }
 
-    // Not called directly, instead call observer.observe
-    void addObserver(Observer<T> *o) { observers.push_back(o); }
+private:
+  friend class Observer<T>;
 
-    void removeObserver(Observer<T> *o) { observers.remove(o); }
+  // Not called directly, instead call observer.observe
+  void addObserver(Observer<T> *o) { observers.push_back(o); }
+
+  void removeObserver(Observer<T> *o) { observers.remove(o); }
 };
 
-template <class T> Observer<T>::~Observer()
-{
-    for (typename std::list<Observable<T> *>::const_iterator iterator = observables.begin(); iterator != observables.end();
-         ++iterator) {
-        (*iterator)->removeObserver(this);
-    }
-    observables.clear();
+template <class T> Observer<T>::~Observer() {
+  for (typename std::list<Observable<T> *>::const_iterator iterator = observables.begin(); iterator != observables.end(); ++iterator) {
+    (*iterator)->removeObserver(this);
+  }
+  observables.clear();
 }
 
-template <class T> void Observer<T>::unobserve(Observable<T> *o)
-{
-    o->removeObserver(this);
-    observables.remove(o);
+template <class T> void Observer<T>::unobserve(Observable<T> *o) {
+  o->removeObserver(this);
+  observables.remove(o);
 }
 
-template <class T> void Observer<T>::observe(Observable<T> *o)
-{
-    observables.push_back(o);
-    o->addObserver(this);
+template <class T> void Observer<T>::observe(Observable<T> *o) {
+  observables.push_back(o);
+  o->addObserver(this);
 }