Refactors to produce slightly less garbage

ckiwi/ckiwi.cpp

@@ -99,7 +99,7 @@ using ConstraintRef = SharedRef<Constraint, KiwiConstraintRef>;
 using VariableRef = SharedRef<Variable, KiwiVarRef>;
 using ConstVariableRef = const SharedRef<const Variable, const KiwiVarRef>;
 
-KiwiErrPtr new_error(KiwiErrPtr base, const std::exception& ex) {
+const KiwiErr* new_error(const KiwiErr* base, const std::exception& ex) {
    if (!std::strcmp(ex.what(), base->message))
       return base;
 
@@ -128,7 +128,7 @@ static const constexpr KiwiErr kKiwiErrNullObjectArg1 {
     "null object passed as argument #1"};
 
 template<typename F>
-inline KiwiErrPtr wrap_err(F&& f) {
+inline const KiwiErr* wrap_err(F&& f) {
    try {
       f();
    } catch (const UnsatisfiableConstraint& ex) {
@@ -183,7 +183,7 @@ inline KiwiErrPtr wrap_err(F&& f) {
 }
 
 template<typename P, typename R, typename F>
-inline KiwiErrPtr wrap_err(P ptr, F&& f) {
+inline const KiwiErr* wrap_err(P ptr, F&& f) {
    if (!ptr) {
       return &kKiwiErrNullObjectArg0;
    }
@@ -191,7 +191,7 @@ inline KiwiErrPtr wrap_err(P ptr, F&& f) {
 }
 
 template<typename P, typename R, typename F>
-inline KiwiErrPtr wrap_err(P ptr, R ref, F&& f) {
+inline const KiwiErr* wrap_err(P ptr, R ref, F&& f) {
    if (!ptr) {
       return &kKiwiErrNullObjectArg0;
    } else if (!ref) {
@@ -245,23 +245,45 @@ int kiwi_var_eq(KiwiVarRef var, KiwiVarRef other) {
    return self && other_ref && self->equals(other_ref);
 }
 
-KiwiConstraintRef
-kiwi_constraint_new(KiwiExpressionConstPtr expression, enum KiwiRelOp op, double strength) {
+void kiwi_expression_del_vars(KiwiExpression* expr) {
+   if (!expr)
+      return;
+
+   for (auto* t = expr->terms; t != expr->terms + expr->term_count; ++t) {
+      VariableRef(t->var).release();
+   }
+}
+
+KiwiConstraintRef kiwi_constraint_new(
+    const KiwiExpression* lhs,
+    const KiwiExpression* rhs,
+    enum KiwiRelOp op,
+    double strength
+) {
    if (strength < 0.0) {
       strength = kiwi::strength::required;
    }
-   std::vector<Term> terms;
-   if (expression) {
-      terms.reserve(expression->term_count);
 
-      for (auto* t = expression->terms; t != expression->terms + expression->term_count; ++t) {
+   std::vector<Term> terms;
+   terms.reserve((lhs ? lhs->term_count : 0) + (rhs ? rhs->term_count : 0));
+
+   if (lhs) {
+      for (auto* t = lhs->terms; t != lhs->terms + lhs->term_count; ++t) {
          ConstVariableRef var(t->var);
          if (var)
             terms.emplace_back(var.cref(), t->coefficient);
       }
    }
+   if (rhs) {
+      for (auto* t = rhs->terms; t != rhs->terms + rhs->term_count; ++t) {
+         ConstVariableRef var(t->var);
+         if (var)
+            terms.emplace_back(var.cref(), -t->coefficient);
+      }
+   }
+
    return make_constraint_cref(
-       Expression(std::move(terms), expression->constant),
+       Expression(std::move(terms), (lhs ? lhs->constant : 0.0) - (rhs ? rhs->constant : 0.0)),
        static_cast<RelationalOperator>(op),
        strength
    );
@@ -311,17 +333,17 @@ int kiwi_constraint_expression(KiwiConstraintRef constraint, KiwiExpression* out
    return n_terms;
 }
 
-KiwiSolverPtr kiwi_solver_new() {
-   return reinterpret_cast<KiwiSolverPtr>(new (std::nothrow) Solver());
+KiwiSolver* kiwi_solver_new() {
+   return reinterpret_cast<KiwiSolver*>(new Solver());
 }
 
-void kiwi_solver_del(KiwiSolverPtr sp) {
+void kiwi_solver_del(KiwiSolver* sp) {
    auto* solver = reinterpret_cast<Solver*>(sp);
    if (solver)
       delete solver;
 }
 
-KiwiErrPtr kiwi_solver_add_constraint(KiwiSolverPtr s, KiwiConstraintRef constraint) {
+const KiwiErr* kiwi_solver_add_constraint(KiwiSolver* s, KiwiConstraintRef constraint) {
    return wrap_err(
        reinterpret_cast<Solver*>(s),
        ConstraintRef(constraint),
@@ -329,7 +351,7 @@ KiwiErrPtr kiwi_solver_add_constraint(KiwiSolverPtr s, KiwiConstraintRef constra
    );
 }
 
-KiwiErrPtr kiwi_solver_remove_constraint(KiwiSolverPtr s, KiwiConstraintRef constraint) {
+const KiwiErr* kiwi_solver_remove_constraint(KiwiSolver* s, KiwiConstraintRef constraint) {
    return wrap_err(
        reinterpret_cast<Solver*>(s),
        ConstraintRef(constraint),
@@ -337,15 +359,15 @@ KiwiErrPtr kiwi_solver_remove_constraint(KiwiSolverPtr s, KiwiConstraintRef cons
    );
 }
 
-bool kiwi_solver_has_constraint(KiwiSolverPtr s, KiwiConstraintRef constraint) {
-   const auto* solver = reinterpret_cast<Solver*>(s);
+bool kiwi_solver_has_constraint(const KiwiSolver* s, KiwiConstraintRef constraint) {
+   const auto* solver = reinterpret_cast<const Solver*>(s);
    ConstraintRef c(constraint);
    if (!solver || !c)
       return 0;
    return solver->hasConstraint(c);
 }
 
-KiwiErrPtr kiwi_solver_add_edit_var(KiwiSolverPtr s, KiwiVarRef var, double strength) {
+const KiwiErr* kiwi_solver_add_edit_var(KiwiSolver* s, KiwiVarRef var, double strength) {
    return wrap_err(
        reinterpret_cast<Solver*>(s),
        VariableRef(var),
@@ -353,21 +375,21 @@ KiwiErrPtr kiwi_solver_add_edit_var(KiwiSolverPtr s, KiwiVarRef var, double stre
    );
 }
 
-KiwiErrPtr kiwi_solver_remove_edit_var(KiwiSolverPtr s, KiwiVarRef var) {
+const KiwiErr* kiwi_solver_remove_edit_var(KiwiSolver* s, KiwiVarRef var) {
    return wrap_err(reinterpret_cast<Solver*>(s), VariableRef(var), [](auto solver, const auto v) {
       solver->removeEditVariable(v);
    });
 }
 
-bool kiwi_solver_has_edit_var(KiwiSolverPtr s, KiwiVarRef var) {
-   const auto* solver = reinterpret_cast<Solver*>(s);
+bool kiwi_solver_has_edit_var(const KiwiSolver* s, KiwiVarRef var) {
+   const auto* solver = reinterpret_cast<const Solver*>(s);
    VariableRef v(var);
    if (!solver || !v)
       return 0;
    return solver->hasEditVariable(v);
 }
 
-KiwiErrPtr kiwi_solver_suggest_value(KiwiSolverPtr s, KiwiVarRef var, double value) {
+const KiwiErr* kiwi_solver_suggest_value(KiwiSolver* s, KiwiVarRef var, double value) {
    return wrap_err(
        reinterpret_cast<Solver*>(s),
        VariableRef(var),
@@ -376,30 +398,30 @@ KiwiErrPtr kiwi_solver_suggest_value(KiwiSolverPtr s, KiwiVarRef var, double val
    );
 }
 
-void kiwi_solver_update_vars(KiwiSolverPtr s) {
+void kiwi_solver_update_vars(KiwiSolver* s) {
    auto* solver = reinterpret_cast<Solver*>(s);
    if (solver)
       solver->updateVariables();
 }
 
-void kiwi_solver_reset(KiwiSolverPtr s) {
+void kiwi_solver_reset(KiwiSolver* s) {
    auto* solver = reinterpret_cast<Solver*>(s);
    if (solver)
       solver->reset();
 }
 
-void kiwi_solver_dump(KiwiSolverPtr s) {
-   auto* solver = reinterpret_cast<Solver*>(s);
+void kiwi_solver_dump(const KiwiSolver* s) {
+   auto* solver = reinterpret_cast<const Solver*>(s);
    if (solver)
-      solver->dump();
+      const_cast<Solver*>(solver)->dump();  // upstream library defect
 }
 
-char* kiwi_solver_dumps(KiwiSolverPtr s) {
-   auto* solver = reinterpret_cast<Solver*>(s);
+char* kiwi_solver_dumps(const KiwiSolver* s) {
+   auto* solver = reinterpret_cast<const Solver*>(s);
    if (!solver)
       return nullptr;
 
-   const auto str = solver->dumps();
+   const auto str = const_cast<Solver*>(solver)->dumps();  // upstream library defect
    const auto buf_size = str.size() + 1;
    auto* buf = static_cast<char*>(std::malloc(buf_size));
    if (!buf)