| Update of /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv29592/ohxl/Conversions
Modified Files:
	all.hpp matrixtooper.hpp opertomatrix.hpp opertoscalar.cpp 
	opertoscalar.hpp opertovector.hpp scalartooper.cpp 
	scalartooper.hpp validations.hpp vectortooper.hpp 
Log Message:
support for coercion
Index: all.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/all.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** all.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- all.hpp	19 Nov 2006 13:08:26 -0000	1.2
***************
*** 19,22 ****
--- 19,23 ----
  #define ohxl_conversions_all_hpp
  
+ #include <oh/Conversions/coerce.hpp>
  #include <ohxl/Conversions/opertoscalar.hpp>
  #include <ohxl/Conversions/opertovector.hpp>
Index: scalartooper.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/scalartooper.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** scalartooper.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- scalartooper.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 26,37 ****
  namespace ObjHandler {
  
!     DLL_API void scalarToXloper(XLOPER &xLong, const long &value);
!     DLL_API void scalarToXloper(XLOPER &xDouble, const double &value);
!     DLL_API void scalarToXloper(XLOPER &xBoolean, const bool &value);
!     DLL_API void scalarToXloper(XLOPER &xString, const std::string &value);
!     DLL_API void scalarToXloper(
!         XLOPER &xAny, 
!         const boost::any &value, 
!         const bool &expandVectors = true);
  
  }
--- 26,34 ----
  namespace ObjHandler {
  
!     DLL_API void scalarToOper(OPER &xLong, const long &value);
!     DLL_API void scalarToOper(OPER &xDouble, const double &value);
!     DLL_API void scalarToOper(OPER &xBoolean, const bool &value);
!     DLL_API void scalarToOper(OPER &xString, const std::string &value);
!     DLL_API void scalarToOper(OPER &xAny, const boost::any &value);
  
  }
Index: opertomatrix.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/opertomatrix.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** opertomatrix.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- opertomatrix.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 31,35 ****
              std::vector<std::vector<T> > ret;
              if (xMatrix.xltype & xltypeErr)
!                 throw Exception("input value is #NULL (xltypeErr)");
              if (xMatrix.xltype & (xltypeMissing | xltypeNil))
                  return ret;
--- 31,35 ----
              std::vector<std::vector<T> > ret;
              if (xMatrix.xltype & xltypeErr)
!                 throw Exception("input value has type=error");
              if (xMatrix.xltype & (xltypeMissing | xltypeNil))
                  return ret;
Index: opertoscalar.cpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/opertoscalar.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** opertoscalar.cpp	16 Nov 2006 12:38:42 -0000	1.1
--- opertoscalar.cpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 18,101 ****
  
  #include <ohxl/Conversions/opertoscalar.hpp>
- #include <oh/exception.hpp>
- #include <oh/utilities.hpp>
- #include <sstream>
  
  namespace ObjHandler {
  
!     DLL_API void operToScalar(long &ret, const OPER &xScalar, const long &defaultValue) {
!         try {
!             //if (xScalar.xltype & xltypeErr)
!             //    throw Exception("input value is #NULL (xltypeErr)");
!             //if (xScalar.xltype & (xltypeMissing | xltypeNil))
!             if (xScalar.xltype & (xltypeMissing | xltypeNil | xltypeErr))
!                 ret = defaultValue;
!             else if (xScalar.xltype == xltypeNum)
!                 ret = xScalar.val.num;
!             else {
!                 OPER xLong;
!                 Excel(xlCoerce, &xLong, 2, &xScalar, TempInt(xltypeInt));
!                 ret = xLong.val.w;
!             }
!         } catch (const std::exception &e) {
!             std::ostringstream msg;
!             msg << "operToScalar cannot coerce to long: " << e.what();
!             throw Exception(msg.str());
          }
      }
  
!     DLL_API void operToScalar(double &ret, const OPER &xScalar, const double &defaultValue) {
!         try {
!             //if (xScalar.xltype & xltypeErr)
!             //    throw Exception("input value is #NULL (xltypeErr)");
!             //if (xScalar.xltype & (xltypeMissing | xltypeNil))
!             if (xScalar.xltype & (xltypeMissing | xltypeNil | xltypeErr))
!                 ret = defaultValue;
!             else if (xScalar.xltype == xltypeNum)
!                 ret = xScalar.val.num;
!             else {
!                 OPER xDouble;
!                 Excel(xlCoerce, &xDouble, 2, &xScalar, TempInt(xltypeNum));
!                 ret = xDouble.val.num;
!             }
!         } catch (const std::exception &e) {
!             std::ostringstream msg;
!             msg << "operToScalar cannot coerce to double: " << e.what();
!             throw Exception(msg.str());
          }
      }
  
!     DLL_API void operToScalar(bool &ret, const OPER &xScalar, const bool &defaultValue) {
!         try {
!             //if (xScalar.xltype & xltypeErr)
!             //    throw Exception("input value is #NULL (xltypeErr)");
!             //if (xScalar.xltype & (xltypeMissing | xltypeNil))
!             if (xScalar.xltype & (xltypeMissing | xltypeNil | xltypeErr))
!                 ret = defaultValue;
!             else if (xScalar.xltype == xltypeBool)
!                 ret = xScalar.val.boolean != 0;
!             else {
!                 OPER xBool;
!                 Excel(xlCoerce, &xBool, 2, &xScalar, TempInt(xltypeBool));
!                 ret = xBool.val.boolean != 0;
!             }
!         } catch (const std::exception &e) {
!             std::ostringstream msg;
!             msg << "operToScalar cannot coerce to bool: " << e.what();
!             throw Exception(msg.str());
          }
      }
  
!     DLL_API void operToScalar(std::string &ret, const OPER &xScalar, const std::string &defaultValue) {
          OPER xTemp;
          bool needToFree = false;
          try {
-             //if (xScalar.xltype & xltypeErr)
-             //    throw Exception("input value is #NULL (xltypeErr)");
-             //if (xScalar.xltype & (xltypeMissing | xltypeNil))
-             if (xScalar.xltype & (xltypeMissing | xltypeNil | xltypeErr)) {
-                 ret = defaultValue;
-                 return;
-             }
              const OPER *xString;
  
--- 18,58 ----
  
  #include <ohxl/Conversions/opertoscalar.hpp>
  
  namespace ObjHandler {
  
!     DLL_API void operToScalar(long &ret, const OPER &xScalar) {
!         if (xScalar.xltype == xltypeNum)
!             ret = xScalar.val.num;
!         else {
!             OPER xLong;
!             Excel(xlCoerce, &xLong, 2, &xScalar, TempInt(xltypeInt));
!             ret = xLong.val.w;
          }
      }
  
!     DLL_API void operToScalar(double &ret, const OPER &xScalar) {
!         if (xScalar.xltype == xltypeNum)
!             ret = xScalar.val.num;
!         else {
!             OPER xDouble;
!             Excel(xlCoerce, &xDouble, 2, &xScalar, TempInt(xltypeNum));
!             ret = xDouble.val.num;
          }
      }
  
!     DLL_API void operToScalar(bool &ret, const OPER &xScalar) {
!         if (xScalar.xltype == xltypeBool)
!             ret = xScalar.val.boolean != 0;
!         else {
!             OPER xBool;
!             Excel(xlCoerce, &xBool, 2, &xScalar, TempInt(xltypeBool));
!             ret = xBool.val.boolean != 0;
          }
      }
  
!     DLL_API void operToScalar(std::string &ret, const OPER &xScalar) {
          OPER xTemp;
          bool needToFree = false;
          try {
              const OPER *xString;
  
***************
*** 108,180 ****
              }
  
!             //if (xString->val.str[0])
!             //    ret.assign(xString->val.str + 1, xString->val.str[0]);
! 
              // expirimental workaround for apparent bug in Excel API
              // where the value for the string length wraps around the byte
! 
!             int stringLength = xString->val.str[0];
!             if (stringLength < 0) stringLength += 257;
!             if (stringLength)
!                 ret.assign(xString->val.str + 1, stringLength);
  
              if (needToFree)
                  Excel(xlFree, 0, 1, &xTemp);
  
!         } catch (const std::exception &e) {
              if (needToFree)
                  Excel(xlFree, 0, 1, &xTemp);
!             std::ostringstream msg;
!             msg << "operToScalar cannot coerce to string: " << e.what();
!             throw Exception(msg.str());
!         }
!     }
! 
!     DLL_API void operToScalar(boost::any &ret, const OPER &xScalar) {
!         //if (xScalar.xltype & xltypeErr)
!         //    throw Exception("input value is #NULL (xltypeErr)");
!         //if (xScalar.xltype & (xltypeMissing | xltypeNil))
!         if (xScalar.xltype & (xltypeMissing | xltypeNil | xltypeErr))
!             ret = boost::any();
!         //else if (xScalar.xltype & xltypeErr)
!         //    ret = InvalidInput;
!         else if (xScalar.xltype == xltypeNum)
!             ret = xScalar.val.num;
!         else if (xScalar.xltype == xltypeBool)
!             ret = xScalar.val.boolean != 0;
!         else if (xScalar.xltype == xltypeStr) {
!             std::string value;
!             operToScalar(value, xScalar);
!             ret = value;
!         } else
!             throw Exception("operToScalar cannot coerce to boost::any: unexpected datatype");
!     }
! 
!     void operToOper(OPER *xTarget, const OPER *xSource) {
!         if (xSource->xltype == xltypeNum) {
!             xTarget->xltype = xltypeNum;
!             xTarget->val.num = xSource->val.num;
!             return;
!         } else if (xSource->xltype == xltypeStr) {
!             int len = xSource->val.str[0];
!             xTarget->val.str = new char[ len + 1 ];
!             if (!xTarget->val.str) 
!                 throw Exception("operToOper: error calling new");
!             xTarget->xltype = xltypeStr | xlbitDLLFree;
!             xTarget->val.str[0] = len;
!             if (len)
!                 strncpy(xTarget->val.str + 1, xSource->val.str + 1, len);
!             return;
!         } else if (xSource->xltype == xltypeErr) {
!             xTarget->xltype = xltypeErr;
!             xTarget->val.err = xSource->val.err;
!             return;
!         } else if (xSource->xltype == xltypeNil) {
!             xTarget->xltype = xltypeNil;
!             return;
!         } else {
!             std::ostringstream msg;
!             msg << "operToOper: unexpected OPER type: " << xSource->xltype;
!             throw Exception(msg.str());
          }
      }
--- 65,84 ----
              }
  
!             if (xString->val.str[0])
!                 ret.assign(xString->val.str + 1, xString->val.str[0]);
              // expirimental workaround for apparent bug in Excel API
              // where the value for the string length wraps around the byte
!             //int stringLength = xString->val.str[0];
!             //if (stringLength < 0) stringLength += 257;
!             //if (stringLength)
!             //    ret.assign(xString->val.str + 1, stringLength);
  
              if (needToFree)
                  Excel(xlFree, 0, 1, &xTemp);
  
!         } catch (...) {
              if (needToFree)
                  Excel(xlFree, 0, 1, &xTemp);
!             throw;
          }
      }
Index: matrixtooper.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/matrixtooper.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** matrixtooper.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- matrixtooper.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 25,32 ****
  
      template <class T>
!     void matrixToXloper(XLOPER &xMatrix, const std::vector<std::vector<T> > &vv) {
          if (vv.empty() || vv[0].empty()) {
-             //xMatrix.xltype = xltypeNum;
-             //xMatrix.val.num = 0;
              xMatrix.xltype = xltypeErr;
              xMatrix.val.err = xlerrNA;
--- 25,30 ----
  
      template <class T>
!     void matrixToOper(OPER &xMatrix, const std::vector<std::vector<T> > &vv) {
          if (vv.empty() || vv[0].empty()) {
              xMatrix.xltype = xltypeErr;
              xMatrix.val.err = xlerrNA;
***************
*** 35,46 ****
          xMatrix.val.array.rows    = vv.size();
          xMatrix.val.array.columns = vv[0].size();
!         xMatrix.val.array.lparray = new XLOPER[xMatrix.val.array.rows * xMatrix.val.array.columns]; 
          if (!xMatrix.val.array.lparray)
!             throw Exception("matrixToXloper: error on call to new");
          xMatrix.xltype = xltypeMulti | xlbitDLLFree;
          for (unsigned int i=0; i<vv.size(); i++) {
              std::vector<T> v = vv[i];
              for (unsigned int j=0; j<v.size(); j++)
!                 scalarToXloper(xMatrix.val.array.lparray[i * v.size() + j], v[j]);
          }
      }
--- 33,44 ----
          xMatrix.val.array.rows    = vv.size();
          xMatrix.val.array.columns = vv[0].size();
!         xMatrix.val.array.lparray = new OPER[xMatrix.val.array.rows * xMatrix.val.array.columns]; 
          if (!xMatrix.val.array.lparray)
!             throw Exception("matrixToOper: error on call to new");
          xMatrix.xltype = xltypeMulti | xlbitDLLFree;
          for (unsigned int i=0; i<vv.size(); i++) {
              std::vector<T> v = vv[i];
              for (unsigned int j=0; j<v.size(); j++)
!                 scalarToOper(xMatrix.val.array.lparray[i * v.size() + j], v[j]);
          }
      }
Index: opertoscalar.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/opertoscalar.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** opertoscalar.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- opertoscalar.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 22,35 ****
  #include <xlsdk/xlsdkdefines.hpp>
  #include <string>
- #include <boost/any.hpp>
  
  namespace ObjHandler {
  
!     DLL_API void operToScalar(long &ret, const OPER &xScalar, const long &defaultValue = 0);
!     DLL_API void operToScalar(double &ret, const OPER &xScalar, const double &defaultValue = 0.);
!     DLL_API void operToScalar(bool &ret, const OPER &xScalar, const bool &defaultValue = false);
!     DLL_API void operToScalar(std::string &ret, const OPER &xScalar, const std::string &defaultValue = "");
!     DLL_API void operToScalar(boost::any &ret, const OPER &xScalar);
!     void operToOper(OPER *xTarget, const OPER *xSource);
  
  }
--- 22,53 ----
  #include <xlsdk/xlsdkdefines.hpp>
  #include <string>
  
  namespace ObjHandler {
  
!     DLL_API void operToScalar(long &ret, const OPER &xScalar);
!     DLL_API void operToScalar(double &ret, const OPER &xScalar);
!     DLL_API void operToScalar(bool &ret, const OPER &xScalar);
!     DLL_API void operToScalar(std::string &ret, const OPER &xScalar);
! 
!     template <class T>
!     T operToScalar(const OPER &xScalar, 
!             const T &defaultValue, 
!             const std::string paramName) {
!         if (xScalar.xltype & xltypeMissing)
!             return defaultValue;
!         try {
!             if (xScalar.xltype & xltypeErr)
!                 throw Exception("input value has type=error");
!             T returnValue;
!             operToScalar(returnValue, xScalar);
!             return returnValue;
!         } catch(const std::exception &e) {
!             std::ostringstream msg;
!             msg << "unable to convert parameter '" << paramName 
!                 << "' to type " << typeid(T).name()
!                 << " - " << e.what();
!             throw Exception(msg.str());
!         }
!     }
  
  }
Index: vectortooper.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/vectortooper.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** vectortooper.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- vectortooper.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 26,33 ****
  
      template <class T>
!     void vectorToXloper(XLOPER &xVector, const std::vector<T> &v) {
          if (v.empty()) {
-             //xVector.xltype = xltypeNum;
-             //xVector.val.num = 0;
              xVector.xltype = xltypeErr;
              xVector.val.err = xlerrNA;
--- 26,31 ----
  
      template <class T>
!     void vectorToOper(OPER &xVector, const std::vector<T> &v) {
          if (v.empty()) {
              xVector.xltype = xltypeErr;
              xVector.val.err = xlerrNA;
***************
*** 42,51 ****
              xVector.val.array.columns = 1;
          }
!         xVector.val.array.lparray = new XLOPER[v.size()]; 
          if (!xVector.val.array.lparray)
!             throw Exception("vectorToXloper: error on call to new");
          xVector.xltype = xltypeMulti | xlbitDLLFree;
          for (unsigned int i=0; i<v.size(); i++)
!             scalarToXloper(xVector.val.array.lparray[i], v[i]);
      }
  
--- 40,49 ----
              xVector.val.array.columns = 1;
          }
!         xVector.val.array.lparray = new OPER[v.size()]; 
          if (!xVector.val.array.lparray)
!             throw Exception("vectorToOper: error on call to new");
          xVector.xltype = xltypeMulti | xlbitDLLFree;
          for (unsigned int i=0; i<v.size(); i++)
!             scalarToOper(xVector.val.array.lparray[i], v[i]);
      }
  
Index: scalartooper.cpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/scalartooper.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** scalartooper.cpp	16 Nov 2006 12:38:42 -0000	1.1
--- scalartooper.cpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 26,49 ****
  namespace ObjHandler {
  
!     DLL_API void scalarToXloper(XLOPER &xLong, const long &value) {
          xLong.xltype = xltypeNum;
          xLong.val.num = value;
      }
  
!     DLL_API void scalarToXloper(XLOPER &xDouble, const double &value) {
          xDouble.xltype = xltypeNum;
          xDouble.val.num = value;
      }
  
!     DLL_API void scalarToXloper(XLOPER &xBoolean, const bool &value) {
          xBoolean.xltype = xltypeBool;
          xBoolean.val.boolean = value;
      }
  
!     DLL_API void scalarToXloper(XLOPER &xString, const std::string &value) {
          int len = __min(XL_MAX_STR_LEN, value.length());
          xString.val.str = new char[ len + 1 ];
          if (!xString.val.str) 
!             throw Exception("stringToXloper: error calling new");
          xString.xltype = xltypeStr | xlbitDLLFree;
          xString.val.str[0] = len;
--- 26,49 ----
  namespace ObjHandler {
  
!     DLL_API void scalarToOper(OPER &xLong, const long &value) {
          xLong.xltype = xltypeNum;
          xLong.val.num = value;
      }
  
!     DLL_API void scalarToOper(OPER &xDouble, const double &value) {
          xDouble.xltype = xltypeNum;
          xDouble.val.num = value;
      }
  
!     DLL_API void scalarToOper(OPER &xBoolean, const bool &value) {
          xBoolean.xltype = xltypeBool;
          xBoolean.val.boolean = value;
      }
  
!     DLL_API void scalarToOper(OPER &xString, const std::string &value) {
          int len = __min(XL_MAX_STR_LEN, value.length());
          xString.val.str = new char[ len + 1 ];
          if (!xString.val.str) 
!             throw Exception("stringToOper: error calling new");
          xString.xltype = xltypeStr | xlbitDLLFree;
          xString.val.str[0] = len;
***************
*** 52,64 ****
      }
  
!     DLL_API void scalarToXloper(
!             XLOPER &xAny, 
!             const boost::any &value, 
!             const bool &expandVectors) {
!         if (value.type() == typeid(XLOPER)) {
!             XLOPER xTemp = boost::any_cast<XLOPER>(value);
              Excel(xlCoerce, &xAny, 1, &xTemp);
!         } else if (value.type() == typeid(XLOPER*)) {
!             XLOPER *xTemp = boost::any_cast<XLOPER*>(value);
              Excel(xlCoerce, &xAny, 1, xTemp);
          } else if (value.type() == typeid(int)) {
--- 52,61 ----
      }
  
!     DLL_API void scalarToOper(OPER &xAny, const boost::any &value) {
!         if (value.type() == typeid(OPER)) {
!             OPER xTemp = boost::any_cast<OPER>(value);
              Excel(xlCoerce, &xAny, 1, &xTemp);
!         } else if (value.type() == typeid(OPER*)) {
!             OPER *xTemp = boost::any_cast<OPER*>(value);
              Excel(xlCoerce, &xAny, 1, xTemp);
          } else if (value.type() == typeid(int)) {
***************
*** 76,152 ****
          } else if (value.type() == typeid(std::string)) {
              std::string s = boost::any_cast<std::string>(value);
!             scalarToXloper(xAny, s);
          } else if (value.type() == typeid(std::vector<long>)) {
!             if (expandVectors) {
!                 std::vector<long> v= boost::any_cast< std::vector<long> >(value);
!                 vectorToXloper(xAny, v);
!             } else {
!                 scalarToXloper(xAny, std::string(VECTOR));
!             }
          } else if (value.type() == typeid(std::vector<double>)) {
!             if (expandVectors) {
!                 std::vector<double> v= boost::any_cast< std::vector<double> >(value);
!                 vectorToXloper(xAny, v);
!             } else {
!                 scalarToXloper(xAny, std::string(VECTOR));
!             }
          } else if (value.type() == typeid(std::vector<bool>)) {
!             if (expandVectors) {
!                 std::vector<bool> v= boost::any_cast< std::vector<bool> >(value);
!                 vectorToXloper(xAny, v);
!             } else {
!                 scalarToXloper(xAny, std::string(VECTOR));
!             }
!         } else if (value.type() == typeid(std::vector< std::string >)) {
!             if (expandVectors) {
!                 std::vector< std::string > v= boost::any_cast< std::vector< std::string > >(value);
!                 vectorToXloper(xAny, v);
!             } else {
!                 scalarToXloper(xAny, std::string(VECTOR));
!             }
!         } else if (value.type() == typeid(std::vector< boost::any >)) {
!             if (expandVectors) {
!                 std::vector< boost::any > v= boost::any_cast< std::vector< boost::any > >(value);
!                 vectorToXloper(xAny, v);
!             } else {
!                 scalarToXloper(xAny, std::string(VECTOR));
!             }
!         } else if (value.type() == typeid(std::vector< std::vector< long > >)) {
!             if (expandVectors) {
!                 std::vector< std::vector<long> >vv = boost::any_cast< std::vector< std::vector<long> > >(value);
!                 vectorToXloper(xAny, vv);
!             } else {
!                 scalarToXloper(xAny, std::string(MATRIX));
!             }
!         } else if (value.type() == typeid(std::vector< std::vector< double > >)) {
!             if (expandVectors) {
!                 std::vector< std::vector< double > >vv = boost::any_cast< std::vector< std::vector< double > > >(value);
!                 matrixToXloper(xAny, vv);
!             } else {
!                 scalarToXloper(xAny, std::string(MATRIX));
!             }
!         } else if (value.type() == typeid(std::vector< std::vector< bool > >)) {
!             if (expandVectors) {
!                 std::vector< std::vector< bool > >vv = boost::any_cast< std::vector< std::vector< bool > > >(value);
! 				// FIXME VC8 compilation fails on this line
! 				// support for matrix of bools not presently required
!                 //matrixToXloper(xAny, vv);
!             } else {
!                 scalarToXloper(xAny, std::string(MATRIX));
!             }
!         } else if (value.type() == typeid(std::vector< std::vector< std::string > >)) {
!             if (expandVectors) {
!                 std::vector< std::vector< std::string > >vv = boost::any_cast< std::vector< std::vector< std::string > > >(value);
!                 matrixToXloper(xAny, vv);
!             } else {
!                 scalarToXloper(xAny, std::string(MATRIX));
!             }
!         } else if (value.type() == typeid(std::vector< std::vector< boost::any > >)) {
!             if (expandVectors) {
!                 std::vector< std::vector< boost::any > >vv = boost::any_cast< std::vector< std::vector< boost::any > > >(value);
!                 matrixToXloper(xAny, vv);
!             } else {
!                 scalarToXloper(xAny, std::string(MATRIX));
!             }
          } else {
              xAny.xltype = xltypeErr;
--- 73,109 ----
          } else if (value.type() == typeid(std::string)) {
              std::string s = boost::any_cast<std::string>(value);
!             scalarToOper(xAny, s);
          } else if (value.type() == typeid(std::vector<long>)) {
!             std::vector<long> v = boost::any_cast<std::vector<long> >(value);
!             vectorToOper(xAny, v);
          } else if (value.type() == typeid(std::vector<double>)) {
!             std::vector<double> v = boost::any_cast<std::vector<double> >(value);
!             vectorToOper(xAny, v);
          } else if (value.type() == typeid(std::vector<bool>)) {
!             std::vector<bool> v = boost::any_cast<std::vector<bool> >(value);
!             vectorToOper(xAny, v);
!         } else if (value.type() == typeid(std::vector<std::string>)) {
!             std::vector<std::string> v = boost::any_cast<std::vector<std::string> >(value);
!             vectorToOper(xAny, v);
!         } else if (value.type() == typeid(std::vector<boost::any>)) {
!             std::vector<boost::any> v = boost::any_cast<std::vector<boost::any> >(value);
!             vectorToOper(xAny, v);
!         } else if (value.type() == typeid(std::vector<std::vector<long> >)) {
!             std::vector<std::vector<long> > vv = boost::any_cast<std::vector<std::vector<long> > >(value);
!             vectorToOper(xAny, vv);
!         } else if (value.type() == typeid(std::vector<std::vector<double> >)) {
!             std::vector<std::vector<double> > vv = boost::any_cast<std::vector<std::vector<double> > >(value);
!             matrixToOper(xAny, vv);
!         } else if (value.type() == typeid(std::vector<std::vector<bool> >)) {
!             std::vector<std::vector<bool> > vv = boost::any_cast<std::vector<std::vector<bool > > >(value);
! 			// FIXME VC8 compilation fails on this line
! 			// support for matrix of bools not presently required
!             //matrixToOper(xAny, vv);
!         } else if (value.type() == typeid(std::vector<std::vector<std::string> >)) {
!             std::vector<std::vector<std::string> > vv = boost::any_cast<std::vector<std::vector<std::string> > >(value);
!             matrixToOper(xAny, vv);
!         } else if (value.type() == typeid(std::vector<std::vector<boost::any> >)) {
!             std::vector<std::vector<boost::any> > vv = boost::any_cast<std::vector<std::vector<boost::any> > >(value);
!             matrixToOper(xAny, vv);
          } else {
              xAny.xltype = xltypeErr;
Index: opertovector.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/opertovector.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** opertovector.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- opertovector.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 31,35 ****
              std::vector<T> ret;
              if (xVector.xltype & xltypeErr)
!                 throw Exception("input value is #NULL (xltypeErr)");
              if (xVector.xltype & (xltypeMissing | xltypeNil))
                  return ret;
--- 31,35 ----
              std::vector<T> ret;
              if (xVector.xltype & xltypeErr)
!                 throw Exception("input value has type=error");
              if (xVector.xltype & (xltypeMissing | xltypeNil))
                  return ret;
Index: validations.hpp
===================================================================
RCS file: /cvsroot/objecthandler/ObjectHandler/ohxl/Conversions/validations.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** validations.hpp	16 Nov 2006 12:38:42 -0000	1.1
--- validations.hpp	19 Nov 2006 13:08:27 -0000	1.2
***************
*** 21,28 ****
  #include <oh/objhandlerdefines.hpp>
  #include <xlsdk/xlsdkdefines.hpp>
- #include <ohxl/functioncall.hpp>
- #include <vector>
  #include <string>
- #include <boost/any.hpp>
  
  namespace ObjHandler {
--- 21,25 ----
***************
*** 31,35 ****
      DLL_API void validateReference(const XLOPER *xReference, const std::string &name);
      DLL_API void stringToChar(char *c, const std::string &s);
-     void operToOper(OPER *xTarget, const OPER *xSource);
  
  }
--- 28,31 ----
 |