From 9db76cec1ec6be76559f8f4f4c396c841d83754b Mon Sep 17 00:00:00 2001
From: Jonathan Lambrechts <jonathan.lambrechts@uclouvain.be>
Date: Wed, 16 Dec 2009 08:47:32 +0000
Subject: [PATCH] compile again without HAVE_LUA (sorry)

---
 Common/Bindings.h          | 74 +++++++++++++++++++++++++++++++++++---
 Solver/dgConservationLaw.h |  6 ----
 Solver/function.h          |  2 ++
 3 files changed, 71 insertions(+), 11 deletions(-)

diff --git a/Common/Bindings.h b/Common/Bindings.h
index 031c3dc400..ce97aa4f3f 100644
--- a/Common/Bindings.h
+++ b/Common/Bindings.h
@@ -1,5 +1,68 @@
-#ifndef _LUNA_SIGNATURE_H_
-#define _LUNA_SIGNATURE_H_
+#ifndef _BINDINGS_H_
+#define _BINDINGS_H_
+
+#ifndef HAVE_LUA //no bindings
+
+class methodBinding{};
+class constructorBinding{};
+template <class objectType, class returnType=void, class arg0Type=void, class arg1Type=void, class arg2Type=void, class arg3Type=void>
+class methodBindingTemplate:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type,arg1Type,arg2Type,arg3Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType, class arg0Type, class arg1Type, class arg2Type>
+class methodBindingTemplate<objectType,returnType,arg0Type,arg1Type,arg2Type,void>:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type,arg1Type,arg2Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType, class arg0Type, class arg1Type>
+class methodBindingTemplate<objectType,returnType,arg0Type,arg1Type,void,void>:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type,arg1Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType, class arg0Type>
+class methodBindingTemplate<objectType,returnType,arg0Type,void,void,void>:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType>
+class methodBindingTemplate<objectType,returnType,void,void,void,void>:public methodBinding {
+  typedef returnType (objectType::*callback)();
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class arg0Type, class arg1Type, class arg2Type>
+class methodBindingTemplate<objectType,void,arg0Type,arg1Type,arg2Type,void>:public methodBinding {
+  typedef void (objectType::*callback)(arg0Type,arg1Type,arg2Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class arg0Type, class arg1Type>
+class methodBindingTemplate<objectType,void,arg0Type,arg1Type,void,void>:public methodBinding {
+  typedef void (objectType::*callback)(arg0Type,arg1Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class arg0Type>
+class methodBindingTemplate<objectType,void,arg0Type,void,void,void>:public methodBinding {
+  typedef void (objectType::*callback)(arg0Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType>
+class methodBindingTemplate<objectType,void,void,void,void,void>:public methodBinding {
+  typedef void (objectType::*callback)();
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template<class objectType, class arg0Type=void, class arg1Type=void, class arg2Type=void, class arg3Type=void>
+class constructorBindingTemplate:public constructorBinding {};
+
+#else // HAVE_LUA
 
 extern "C" {
 #include "lua.h"
@@ -8,9 +71,6 @@ extern "C" {
 #include <vector>
 
 
-class binding {
-};
-
 class methodBinding {
   public:
   std::string _luaname;
@@ -25,6 +85,9 @@ class constructorBinding {
   virtual int call (lua_State *L)=0;
 };
 
+
+// this class is largely copied from luna
+// todo : add  reference to luna and check luna  licence
 template <typename T> class classBinding {
   typedef struct { T *pT; bool owned;} userdataType;
 public:
@@ -455,3 +518,4 @@ class constructorBindingTemplate<objectType,void,void,void,void>:public construc
   }
 };
 #endif
+#endif
diff --git a/Solver/dgConservationLaw.h b/Solver/dgConservationLaw.h
index f500f95878..7e037cd3e1 100644
--- a/Solver/dgConservationLaw.h
+++ b/Solver/dgConservationLaw.h
@@ -9,10 +9,8 @@
 #include "fullMatrix.h"
 class dataCacheDouble;
 class dataCacheMap;
-#ifdef HAVE_LUA
 class constructorBinding;
 class methodBinding;
-#endif
 
 class dgConservationLaw;
 
@@ -20,12 +18,10 @@ class dgBoundaryCondition {
  public:
   virtual ~dgBoundaryCondition () {}
   virtual dataCacheDouble *newBoundaryTerm(dataCacheMap &cacheMapLeft) const = 0;
-#if defined(HAVE_LUA)
   static const char className[];
   static const char parentClassName[];
   static methodBinding *methods[];
   static constructorBinding *constructorMethod;
-#endif
 };
 
 class dgConservationLaw {
@@ -62,12 +58,10 @@ class dgConservationLaw {
   dgBoundaryCondition *newOutsideValueBoundary(std::string outsideValueFunctionName);
   dgBoundaryCondition *new0FluxBoundary();
 
-  #ifdef HAVE_LUA
   static const char className[];
   static const char parentClassName[];
   static methodBinding *methods[];
   static constructorBinding *constructorMethod;
-  #endif
 };
 
 dgConservationLaw *dgNewPerfectGasLaw2d();
diff --git a/Solver/function.h b/Solver/function.h
index 666c60686e..88b6fe5fb6 100644
--- a/Solver/function.h
+++ b/Solver/function.h
@@ -7,6 +7,8 @@
 #include <fullMatrix.h>
 class dataCacheMap;
 class MElement;
+class methodBinding;
+class constructorBinding;
 
 // those classes manage complex function dependencies and keep their values in cache so that they are not recomputed when it is not necessary. To do this, we use three classes : function, dataCache and dataCacheMap. The workflow is :
 //
-- 
GitLab