Merge pull request #95 from woodwan/woodwan/TolerateMissingMethods

## Description
Suppose two components collaborate by passing abstract class instances between one another.  The definition of the abstract class interface against which the two components were built must be exactly the same.

For example, suppose we add a new method to an interface and regenerate one of the components, but not the other.

If we pass an implementation of this interface from the component _without_ knowledge of the new method to the component _with_ knowledge of the new method, the generated ACT code in the newly-generated component will throw an error at the point where the object is passed over because an expected method is missing.

It's desirable to have a little more leeway here, since during development of collaborating components it is often the case that they will go temporarily 'out of sync ' - e.g. testing a development build against a prebuilt version of a collaborator.

I've address this in the generated C++ binding here by throwing an error at the point of calling a missing abstract method, not at the point where loading it fails.

## Verification

Created two 'concrete' components, a shared 'base' component definition containing an abstract class, and a executable consuming them.

One component produces an instance of the interface, the other consumes it. The executable 'wires' them together. Generated, built and verified that this worked.

Modified the interface to add a new method. Regenerated the 'consumer' component (so it should expect the new method, which won't be present.)  When the consumer is regenerated _without_ these changes, it throws up an error. When the consumer is generated _with_ these changes, it works, since it does not attempt to call the new method.

Author: woodwan

Source/buildbindingccpp.go

@@ -609,7 +609,7 @@ func buildDynamicCPPMethodDeclaration(method ComponentDefinitionMethod, NameSpac
 }
 
 func writeDynamicCPPMethod(component ComponentDefinition, method ComponentDefinitionMethod, w LanguageWriter, ClassIdentifier string, ClassName string,
-	implementationLines []string, isGlobal bool, includeComments bool, checkErrorSafely bool, useCPPTypes bool, ExplicitLinking bool) error {
+	implementationLines []string, isGlobal bool, includeComments bool, checkErrorSafely bool, useCPPTypes bool, ExplicitLinking bool, isAbstract bool) error {
 	NameSpace := component.NameSpace
 
 	CMethodName := ""
@@ -868,6 +868,10 @@ func writeDynamicCPPMethod(component ComponentDefinition, method ComponentDefini
 
 	w.Writeln("  {")
 	w.Writelns("    ", definitionCodeLines)
+	if isAbstract {
+		w.Writeln("    if (!%s)", CMethodName)
+		w.Writeln("      throw E%sException(%s_ERROR_NOTIMPLEMENTED, \"Method '%s' not found\");", NameSpace, strings.ToUpper(NameSpace), method.MethodName)
+	}
 	if requiresInitCall {
 		w.Writeln("    %s%s(%s)%s;", checkErrorCodeBegin, CMethodName, initCallParameters, checkErrorCodeEnd)
 	}
@@ -903,8 +907,12 @@ func writeLoadingOfClassFunctionTable(component ComponentDefinition, stubfile La
 
 	for k := 0; k < len(class.Methods); k++ {
 		method := class.Methods[k]
+		readMethod := "readMethodInto"
+		if (class.IsAbstract()) {
+			readMethod = "readAbstractMethodInto"
+		}
 		CMethodName := strings.ToLower(fmt.Sprintf("%s_%s_%s", NameSpace, class.ClassName, method.MethodName));
-		stubfile.Writeln("      %s::readMethodInto(pLookupFunction, \"%s\", (void**)&(%s->m_%s_%s));", WrapperName, CMethodName, sTableName, class.ClassName, method.MethodName);
+		stubfile.Writeln("      %s::%s(pLookupFunction, \"%s\", (void**)&(%s->m_%s_%s));", WrapperName, readMethod, CMethodName, sTableName, class.ClassName, method.MethodName);
 	}
 }
 
@@ -1413,6 +1421,13 @@ func buildCppHeader(component ComponentDefinition, w LanguageWriter, NameSpace s
 	w.Writeln("  }")
 	w.Writeln("")
 
+	w.Writeln("  static void readAbstractMethodInto(%sSymbolLookupType pLookupMethod, std::string sFunctionName, void** pfnTarget) {", NameSpace )
+	w.Writeln("    %sResult eLookupError = (*pLookupMethod)(sFunctionName.c_str(), pfnTarget);", NameSpace);
+	w.Writeln("    if (eLookupError != %s_SUCCESS)", strings.ToUpper(NameSpace))
+	w.Writeln("      *pfnTarget = 0;")
+	w.Writeln("  }")
+	w.Writeln("")
+
 
 	for i := 0; i < len(component.Classes); i++ {
 		class := component.Classes[i]
@@ -1510,7 +1525,7 @@ func buildCppHeader(component ComponentDefinition, w LanguageWriter, NameSpace s
 			checkErrorSafely = true
 		}
 
-		err = writeDynamicCPPMethod(component, method, w, ClassIdentifier, "Wrapper", implementationLines, true, true, checkErrorSafely, useCPPTypes, ExplicitLinking)
+		err = writeDynamicCPPMethod(component, method, w, ClassIdentifier, "Wrapper", implementationLines, true, true, checkErrorSafely, useCPPTypes, ExplicitLinking, false)
 		if err != nil {
 			return err
 		}
@@ -1599,7 +1614,7 @@ func buildCppHeader(component ComponentDefinition, w LanguageWriter, NameSpace s
 				checkErrorSafely = true
 			}
 
-			err := writeDynamicCPPMethod(component, method, w, ClassIdentifier, class.ClassName, make([]string,0), false, true, checkErrorSafely, useCPPTypes, ExplicitLinking)
+			err := writeDynamicCPPMethod(component, method, w, ClassIdentifier, class.ClassName, make([]string,0), false, true, checkErrorSafely, useCPPTypes, ExplicitLinking, class.IsAbstract())
 			if err != nil {
 				return err
 			}