Clean up pointer use:

* Use unique_ptr for Actions instead of manual memory management
 * Use unique_ptr in KeywordDatabase
 * Use unique_ptr instead of shared_ptr for file formats
 * Don't pass shared_ptr to Reader/Writer, use references instead
Also
 * Switch to C++17 so we can use map::try_emplace

src/data/action/symbol_part.cpp

@@ -97,6 +97,7 @@ ControlPointMoveAction::ControlPointMoveAction(const set<ControlPointP>& points)
   FOR_EACH(p, points) {
     oldValues.push_back(p->pos);
   }
+  perform(false);
 }
 
 String ControlPointMoveAction::getName(bool to_undo) const {
@@ -104,12 +105,15 @@ String ControlPointMoveAction::getName(bool to_undo) const {
 }
 
 void ControlPointMoveAction::perform(bool to_undo) {
+  if (to_undo != done) return;
+  done = !to_undo;
   FOR_EACH_2(p,points,  op,oldValues) {
     swap(p->pos, op);
   }
 }
 
-void ControlPointMoveAction::move (const Vector2D& deltaDelta) {
+void ControlPointMoveAction::move(const Vector2D& deltaDelta) {
+  assert(done);
   delta += deltaDelta;
   // Move each point by delta, possibly constrained
   set<ControlPointP>::const_iterator it  = points.begin();
@@ -128,18 +132,23 @@ HandleMoveAction::HandleMoveAction(const SelectedHandle& handle)
   , old_other (handle.getOther())
   , constrain(false)
   , snap(0)
-{}
+{
+  perform(false);
+}
 
 String HandleMoveAction::getName(bool to_undo) const {
   return _ACTION_("move handle");
 }
 
 void HandleMoveAction::perform(bool to_undo) {
+  if (to_undo != done) return;
+  done = !to_undo;
   swap(old_handle, handle.getHandle());
   swap(old_other,  handle.getOther());
 }
 
 void HandleMoveAction::move(const Vector2D& deltaDelta) {
+  assert(done);
   delta += deltaDelta;
   handle.getHandle() = constrain_snap_vector_offset(handle.point->pos, old_handle + delta, constrain, snap);
   handle.getOther()  = old_other;
@@ -246,7 +255,7 @@ void CurveDragAction::move(const Vector2D& delta, double t) {
 
 ControlPointAddAction::ControlPointAddAction(const SymbolShapeP& shape, UInt insert_after, double t)
   : shape(shape)
-  , new_point(new ControlPoint())
+  , new_point(make_shared<ControlPoint>())
   , insert_after(insert_after)
   , point1(shape->getPoint(insert_after))
   , point2(shape->getPoint(insert_after + 1))
@@ -419,13 +428,13 @@ void ControlPointRemoveAction::perform(bool to_undo) {
 }
 
 
-Action* control_point_remove_action(const SymbolShapeP& shape, const set<ControlPointP>& to_delete) {
+unique_ptr<Action> control_point_remove_action(const SymbolShapeP& shape, const set<ControlPointP>& to_delete) {
   if (shape->points.size() - to_delete.size() < 2) {
     // TODO : remove part?
     //make_intrusive<ControlPointRemoveAllAction>(part);
-    return 0; // no action
+    return unique_ptr<Action>(); // no action
   } else {
-    return new ControlPointRemoveAction(shape, to_delete);
+    return make_unique<ControlPointRemoveAction>(shape, to_delete);
   }
 }
 

src/data/action/symbol_part.hpp

@@ -40,10 +40,18 @@ Vector2D constrain_snap_vector_offset(const Vector2D& off1, const Vector2D& d, b
 /** Takes the closest snap */
 Vector2D constrain_snap_vector_offset(const Vector2D& off1, const Vector2D& off2, const Vector2D& d, bool constrain, int steps);
 
+// ----------------------------------------------------------------------------- : Base class
+
+/// An action that by itself doesn't do anything, but can later be extended after it is performed
+class ExtendableAction : public Action {
+protected:
+  bool done = false;
+};
+
 // ----------------------------------------------------------------------------- : Move control point
 
 /// Moving a control point in a symbol
-class ControlPointMoveAction : public Action {
+class ControlPointMoveAction : public ExtendableAction {
   public:
   ControlPointMoveAction(const set<ControlPointP>& points);
   
@@ -65,7 +73,7 @@ class ControlPointMoveAction : public Action {
 // ----------------------------------------------------------------------------- : Move handle
 
 /// Moving a handle(before/after) of a control point in a symbol
-class HandleMoveAction : public Action {
+class HandleMoveAction : public ExtendableAction {
   public:
   HandleMoveAction(const SelectedHandle& handle);
   
@@ -169,7 +177,7 @@ class ControlPointAddAction : public Action {
 
 /// Action that removes any number of points from a symbol shape
 /// TODO: If less then 3 points are left removes the entire shape?
-Action* control_point_remove_action(const SymbolShapeP& shape, const set<ControlPointP>& to_delete);
+unique_ptr<Action> control_point_remove_action(const SymbolShapeP& shape, const set<ControlPointP>& to_delete);
 
 
 

src/data/action/value.cpp

@@ -81,14 +81,24 @@ class SimpleValueAction : public ValueAction {
   typename T::ValueType new_value;
 };
 
-ValueAction* value_action(const ChoiceValueP&         value, const Defaultable<String>& new_value) { return new SimpleValueAction<ChoiceValue,         true> (value, new_value); }
-ValueAction* value_action(const ColorValueP&          value, const Defaultable<Color>&  new_value) { return new SimpleValueAction<ColorValue,          true> (value, new_value); }
-ValueAction* value_action(const ImageValueP&          value, const FileName&            new_value) { return new SimpleValueAction<ImageValue,          false>(value, new_value); }
-ValueAction* value_action(const SymbolValueP&         value, const FileName&            new_value) { return new SimpleValueAction<SymbolValue,         false>(value, new_value); }
-ValueAction* value_action(const PackageChoiceValueP&  value, const String&              new_value) { return new SimpleValueAction<PackageChoiceValue,  false>(value, new_value); }
-ValueAction* value_action(const MultipleChoiceValueP& value, const Defaultable<String>& new_value, const String& last_change) {
+unique_ptr<ValueAction> value_action(const ChoiceValueP& value, const Defaultable<String>& new_value) {
+  return make_unique<SimpleValueAction<ChoiceValue, true>>(value, new_value);
+}
+unique_ptr<ValueAction> value_action(const ColorValueP& value, const Defaultable<Color>& new_value) {
+  return make_unique<SimpleValueAction<ColorValue, true>>(value, new_value);
+}
+unique_ptr<ValueAction> value_action(const ImageValueP& value, const FileName& new_value) {
+  return make_unique<SimpleValueAction<ImageValue, false>>(value, new_value);
+}
+unique_ptr<ValueAction> value_action(const SymbolValueP& value, const FileName& new_value) {
+  return make_unique<SimpleValueAction<SymbolValue, false>>(value, new_value);
+}
+unique_ptr<ValueAction> value_action(const PackageChoiceValueP& value, const String& new_value) {
+  return make_unique<SimpleValueAction<PackageChoiceValue, false>>(value, new_value);
+}
+unique_ptr<ValueAction> value_action(const MultipleChoiceValueP& value, const Defaultable<String>& new_value, const String& last_change) {
   MultipleChoiceValue::ValueType v = { new_value, last_change };
-  return new SimpleValueAction<MultipleChoiceValue, false>(value, v);
+  return make_unique<SimpleValueAction<MultipleChoiceValue, false>>(value, v);
 }
 
 
@@ -133,7 +143,7 @@ TextValue& TextValueAction::value() const {
 }
 
 
-TextValueAction* toggle_format_action(const TextValueP& value, const String& tag, size_t start_i, size_t end_i, size_t start, size_t end, const String& action_name) {
+unique_ptr<TextValueAction> toggle_format_action(const TextValueP& value, const String& tag, size_t start_i, size_t end_i, size_t start, size_t end, const String& action_name) {
   if (start > end) {
     swap(start, end);
     swap(start_i, end_i);
@@ -165,11 +175,11 @@ TextValueAction* toggle_format_action(const TextValueP& value, const String& tag
   if (value->value() == new_value) {
     return nullptr; // no changes
   } else {
-    return new TextValueAction(value, start, end, end, new_value, action_name);
+    return make_unique<TextValueAction>(value, start, end, end, new_value, action_name);
   }
 }
 
-TextValueAction* typing_action(const TextValueP& value, size_t start_i, size_t end_i, size_t start, size_t end, const String& replacement, const String& action_name)  {
+unique_ptr<TextValueAction> typing_action(const TextValueP& value, size_t start_i, size_t end_i, size_t start, size_t end, const String& replacement, const String& action_name)  {
   bool reverse = start > end;
   if (reverse) {
     swap(start, end);
@@ -181,9 +191,9 @@ TextValueAction* typing_action(const TextValueP& value, size_t start_i, size_t e
     return nullptr;
   } else {
     if (reverse) {
-      return new TextValueAction(value, end, start, start+untag(replacement).size(), new_value, action_name);
+      return make_unique<TextValueAction>(value, end, start, start+untag(replacement).size(), new_value, action_name);
     } else {
-      return new TextValueAction(value, start, end, start+untag(replacement).size(), new_value, action_name);
+      return make_unique<TextValueAction>(value, start, end, start+untag(replacement).size(), new_value, action_name);
     }
   }
 }
@@ -248,9 +258,9 @@ ValueActionPerformer::ValueActionPerformer(const ValueP& value, Card* card, cons
 {}
 ValueActionPerformer::~ValueActionPerformer() {}
 
-void ValueActionPerformer::addAction(ValueAction* action) {
+void ValueActionPerformer::addAction(unique_ptr<ValueAction>&& action) {
   action->isOnCard(card);
-  set->actions.addAction(action);
+  set->actions.addAction(move(action));
 }
 
 Package& ValueActionPerformer::getLocalPackage() {

src/data/action/value.hpp

@@ -55,12 +55,12 @@ class ValueAction : public Action {
 // ----------------------------------------------------------------------------- : Simple
 
 /// Action that updates a Value to a new value
-ValueAction* value_action(const ChoiceValueP&         value, const Defaultable<String>& new_value);
-ValueAction* value_action(const MultipleChoiceValueP& value, const Defaultable<String>& new_value, const String& last_change);
-ValueAction* value_action(const ColorValueP&          value, const Defaultable<Color>&  new_value);
-ValueAction* value_action(const ImageValueP&          value, const FileName&            new_value);
-ValueAction* value_action(const SymbolValueP&         value, const FileName&            new_value);
-ValueAction* value_action(const PackageChoiceValueP&  value, const String&              new_value);
+unique_ptr<ValueAction> value_action(const ChoiceValueP&         value, const Defaultable<String>& new_value);
+unique_ptr<ValueAction> value_action(const MultipleChoiceValueP& value, const Defaultable<String>& new_value, const String& last_change);
+unique_ptr<ValueAction> value_action(const ColorValueP&          value, const Defaultable<Color>&  new_value);
+unique_ptr<ValueAction> value_action(const ImageValueP&          value, const FileName&            new_value);
+unique_ptr<ValueAction> value_action(const SymbolValueP&         value, const FileName&            new_value);
+unique_ptr<ValueAction> value_action(const PackageChoiceValueP&  value, const String&              new_value);
 
 // ----------------------------------------------------------------------------- : Text
 
@@ -86,11 +86,11 @@ class TextValueAction : public ValueAction {
 };
 
 /// Action for toggling some formating tag on or off in some range
-TextValueAction* toggle_format_action(const TextValueP& value, const String& tag, size_t start_i, size_t end_i, size_t start, size_t end, const String& action_name);
+unique_ptr<TextValueAction> toggle_format_action(const TextValueP& value, const String& tag, size_t start_i, size_t end_i, size_t start, size_t end, const String& action_name);
 
 /// Typing in a TextValue, replace the selection [start...end) with replacement
 /** start and end are cursor positions, start_i and end_i are indices*/
-TextValueAction* typing_action(const TextValueP& value, size_t start_i, size_t end_i, size_t start, size_t end, const String& replacement, const String& action_name);
+unique_ptr<TextValueAction> typing_action(const TextValueP& value, size_t start_i, size_t end_i, size_t start, size_t end, const String& replacement, const String& action_name);
 
 // ----------------------------------------------------------------------------- : Reminder text
 
@@ -169,7 +169,7 @@ class ValueActionPerformer {
   ValueActionPerformer(const ValueP& value, Card* card, const SetP& set);
   ~ValueActionPerformer();
   /// Perform an action. The performer takes ownerwhip of the action.
-  void addAction(ValueAction* action);
+  void addAction(unique_ptr<ValueAction>&& action);
   
   const ValueP value; ///< The value
   Package& getLocalPackage();