Added more doxygen documentation

[germs.git] / src / sortaction.h

diff --git a/src/sortaction.h b/src/sortaction.h
index b6c5df74278f85d08540678674ffb6c7d384a650..ec9a023710961ee0978651fe46f1520d6d18039d 100644 (file)
--- a/src/sortaction.h
+++ b/src/sortaction.h
@@ -21,20 +21,100 @@
 #ifndef __SORTACTION_H__
 #define __SORTACTION_H__
 
+#include <tr1/memory>
+#include <string>
+class GeneOrder;
+
+
+/**
+ * Abstraction for a sort action implementation, this is the base that other
+ * actions inherits from.
+ */
+class SortActionImpl{
+       public:
+
+               virtual ~SortActionImpl(){};
+
+               /**
+                * Applies the action on the GeneOrder and returning it.
+                */
+               virtual GeneOrder& operator()(GeneOrder& go) const = 0;
+
+               /**
+                * Compares sort actions.
+                */
+               virtual bool operator==(const SortActionImpl& sa) const = 0;
+               
+               /**
+                * Gives a string representation of the action, for output
+                */
+               virtual std::string toString() const = 0;
+};
+
 /**
- * Abstraction of a sort action, keeping track of score
+ * Abstraction of a sort action, all SortActionImpls has to be immutable.
  *
  * \author Michael Andreen
  */
 class SortAction{
        public:
+               typedef std::tr1::shared_ptr<SortActionImpl> ActionPointer;
 
-               virtual ~SortAction(){};
+               /**
+                * Creates a new sort action, given a specified action.
+                * SortAction promises to remove the given action.
+                */
+               SortAction(SortActionImpl* sa): _action(sa){
+               }
+
+               SortAction(const SortAction& sa): _action(sa._action){
+               }
+
+               const SortAction& operator=(const SortAction& sa){
+                       if (this != &sa)
+                               _action = sa._action;
+                       return *this;
+               }
+               
+               ~SortAction(){};
+
+               /**
+                * Applies the action on the GeneOrder and returning it.
+                */
+               GeneOrder& operator()(GeneOrder& go) const{
+                       return (*_action)(go);
+               }
+
+               /**
+                * Compares sort actions.
+                */
+               bool operator==(const SortAction& sa) const{
+                       return (*_action) == (*sa._action);
+               }
+
+               /**
+                * Compares sort actions.
+                */
+               bool operator==(const SortActionImpl& sa) const{
+                       return (*_action) == sa;
+               }
+               
+               /**
+                * Gives a string representation of the action, for output
+                */
+               std::string toString() const{
+                       return _action->toString();
+               }
 
                /**
-                * Sort SortActions by score
+                * Gives access to the implementation
                 */
-               virtual operator<(const SortAction& sa) const;
+               const SortActionImpl& impl() const{
+                       return *_action;
+               }
+       private:
+               ActionPointer _action;
+
 };
 
 #endif