Made changes to the C++ API in order to allow for proper error

propagation up to the toplevel error handler in BPY_txt_do_python_Text().

Before these changes were made, the operator() methods of predicates
and functions, for example, returned a value of various types such as
bool, double and Vec2f.  These returned values were not capable to
represent an error state in many cases.

Now the operator() methods always return 0 on normal exit and -1 on
error.  The original returned values are stored in the "result" member
variables of the predicate/function classes.

This means that if we have a code fragment like below:

  UnaryPredicate1D& pred;
  Interface1D& inter;
  if (pred(inter)) {
    /* do something */
  }

then we have to rewrite it as follows:

  UnaryPredicate1D& pred;
  Interface1D& inter;
  if (pred(inter) < 0)
    return -1; /* an error in pred() is propagated */
  if (pred.result) {
    /* do something */
  }

Suppose that pred is a user-defined predicate in Python, i.e. the predicate
is likely error-prone (especially when debugging the predicate).  The first
code fragment shown above prevents the proper error propagation because
the boolean return value of UnaryPredicate1D::operator() cannot inform the
occurrence of an error to the caller; the second code fragment can.

In addition to the operator() methods of predicates and functions, similar
improvements have been made to all other C++ API functions and methods that
are involved in the execution of user-defined Python code snippets.  Changes
in the signatures of functions and methods are summarized as follows (note
that all subclasses of listed classes are also subject to the changes).

Old signatures:
virtual void Iterator::increment();
virtual void Iterator::decrement();
virtual void ChainingIterator::init();
virtual ViewEdge * ChainingIterator::traverse(const AdjacencyIterator &it);
static void Operators::select(UnaryPredicate1D& pred);
static void Operators::chain(ViewEdgeInternal::ViewEdgeIterator& it,
	    UnaryPredicate1D& pred, UnaryFunction1D_void& modifier);
static void Operators::chain(ViewEdgeInternal::ViewEdgeIterator& it,
	    UnaryPredicate1D& pred);  
static void Operators::bidirectionalChain(ChainingIterator& it,
	    UnaryPredicate1D& pred);
static void Operators::bidirectionalChain(ChainingIterator& it);
static void Operators::sequentialSplit(UnaryPredicate0D& startingPred,
	    UnaryPredicate0D& stoppingPred, float sampling = 0);
static void Operators::sequentialSplit(UnaryPredicate0D& pred, float sampling = 0);
static void Operators::recursiveSplit(UnaryFunction0D<double>& func,
	    UnaryPredicate1D& pred, float sampling = 0);
static void Operators::recursiveSplit(UnaryFunction0D<double>& func,
	    UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling = 0);
static void Operators::sort(BinaryPredicate1D& pred);
static void Operators::create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders);
virtual bool UnaryPredicate0D::operator()(Interface0DIterator& it);
virtual bool BinaryPredicate0D::operator()(Interface0D& inter1, Interface0D& inter2);
virtual bool UnaryPredicate1D::operator()(Interface1D& inter);
virtual bool BinaryPredicate1D::operator()(Interface1D& inter1, Interface1D& inter2);
virtual void StrokeShader::shade(Stroke& ioStroke) const;
virtual T UnaryFunction0D::operator()(Interface0DIterator& iter);
virtual T UnaryFunction1D::operator()(Interface1D& inter);

New signatures:
virtual int Iterator::increment();
virtual int Iterator::decrement();
virtual int ChainingIterator::init();
virtual int ChainingIterator::traverse(const AdjacencyIterator &it);
static int Operators::select(UnaryPredicate1D& pred);
static int Operators::chain(ViewEdgeInternal::ViewEdgeIterator& it,
	   UnaryPredicate1D& pred, UnaryFunction1D_void& modifier);
static int Operators::chain(ViewEdgeInternal::ViewEdgeIterator& it,
	   UnaryPredicate1D& pred);  
static int Operators::bidirectionalChain(ChainingIterator& it,
	   UnaryPredicate1D& pred);
static int Operators::bidirectionalChain(ChainingIterator& it);
static int Operators::sequentialSplit(UnaryPredicate0D& startingPred,
	   UnaryPredicate0D& stoppingPred, float sampling = 0);
static int Operators::sequentialSplit(UnaryPredicate0D& pred, float sampling = 0);
static int Operators::recursiveSplit(UnaryFunction0D<double>& func,
	   UnaryPredicate1D& pred, float sampling = 0);
static int Operators::recursiveSplit(UnaryFunction0D<double>& func,
	   UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling = 0);
static int Operators::sort(BinaryPredicate1D& pred);
static int Operators::create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders);
virtual int UnaryPredicate0D::operator()(Interface0DIterator& it);
virtual int BinaryPredicate0D::operator()(Interface0D& inter1, Interface0D& inter2);
virtual int UnaryPredicate1D::operator()(Interface1D& inter);
virtual int BinaryPredicate1D::operator()(Interface1D& inter1, Interface1D& inter2);
virtual int StrokeShader::shade(Stroke& ioStroke) const;
virtual int UnaryFunction0D::operator()(Interface0DIterator& iter);
virtual int UnaryFunction1D::operator()(Interface1D& inter);

1 files changed, 11 insertions, 11 deletions

diff --git a/source/blender/freestyle/intern/stroke/Operators.h b/source/blender/freestyle/intern/stroke/Operators.h
index 804ee4d7056..cff9e120c1a 100755
--- a/source/blender/freestyle/intern/stroke/Operators.h
+++ b/source/blender/freestyle/intern/stroke/Operators.h
@@ -64,7 +64,7 @@ public:
    *  a specified condition.
    *  \param pred The predicate expressing this condition
    */
-  static void select(UnaryPredicate1D& pred);
+  static int select(UnaryPredicate1D& pred);
 
   /*! Builds a set of chains from the current set of ViewEdges.
    *  Each ViewEdge of the current list starts a new chain. The chaining
@@ -83,7 +83,7 @@ public:
    *           is used to modify the processed ViewEdge state (the timestamp
    *           incrementation is a typical illustration of such a modifier)
    */
-  static void chain(ViewEdgeInternal::ViewEdgeIterator& it,
+  static int chain(ViewEdgeInternal::ViewEdgeIterator& it,
 		    UnaryPredicate1D& pred,
 		    UnaryFunction1D_void& modifier);
 
@@ -103,7 +103,7 @@ public:
    *           The predicate on the ViewEdge that expresses the stopping
    *           condition.
    */
-  static void chain(ViewEdgeInternal::ViewEdgeIterator& it,
+  static int chain(ViewEdgeInternal::ViewEdgeIterator& it,
 		    UnaryPredicate1D& pred);  
 
   /*! Builds a set of chains from the current set of ViewEdges.
@@ -126,7 +126,7 @@ public:
    *           The predicate on the ViewEdge that expresses the stopping
    *           condition.
    */
-  static void bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred);
+  static int bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred);
 
   /*! The only difference with the above bidirectional chaining algorithm is 
    *  that we don't need to pass a stopping criterion. This might be desirable 
@@ -149,7 +149,7 @@ public:
    *           The ChainingIterator on the ViewEdges of the ViewMap. It contains
    *           the chaining rule.
    */
-  static void bidirectionalChain(ChainingIterator& it);
+  static int bidirectionalChain(ChainingIterator& it);
 
   /*! Splits each chain of the current set of chains in a sequential way.
    *  The points of each chain are processed (with a specified sampling) sequentially.
@@ -170,7 +170,7 @@ public:
    *           evaluation. (The chain is not actually resampled, a virtual point
    *           only progresses along the curve using this resolution)
    */
-  static void sequentialSplit(UnaryPredicate0D& startingPred, UnaryPredicate0D& stoppingPred, 
+  static int sequentialSplit(UnaryPredicate0D& startingPred, UnaryPredicate0D& stoppingPred, 
                               float sampling = 0.f);
 
   /*! Splits each chain of the current set of chains in a sequential way.
@@ -185,7 +185,7 @@ public:
    *           evaluation. (The chain is not actually resampled, a virtual point
    *           only progresses along the curve using this resolution)
    */
-  static void sequentialSplit(UnaryPredicate0D& pred, 
+  static int sequentialSplit(UnaryPredicate0D& pred, 
                               float sampling = 0.f);
 
   /*! Splits the current set of chains in a recursive way.
@@ -206,7 +206,7 @@ public:
    *           evaluation. (The chain is not actually resampled, a virtual point
    *           only progresses along the curve using this resolution)
    */
-  static void recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate1D& pred, float sampling = 0);
+  static int recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate1D& pred, float sampling = 0);
 
   /*! Splits the current set of chains in a recursive way.
    *  We process the points of each chain (with a specified sampling) to find
@@ -238,14 +238,14 @@ public:
    *           only progresses along the curve using this resolution)
    *           
    */
-  static void recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling = 0);
+  static int recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling = 0);
     
   /*! Sorts the current set of chains (or viewedges) according to the
    * comparison predicate given as argument.
    *  \param pred
    *           The binary predicate used for the comparison
    */
-  static void sort(BinaryPredicate1D& pred);
+  static int sort(BinaryPredicate1D& pred);
 
   /*! Creates and shades the strokes from the current set of chains.
    *  A predicate can be specified to make a selection pass on the
@@ -256,7 +256,7 @@ public:
    *  \param shaders
    *           The list of shaders used to shade the strokes
    */
-  static void create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders);
+  static int create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders);
 
   //
   // Data access