Octave: add {save,load}_{ascii,binary,hdf} functions that silently do nothing;

give default operator mappings a more conventional suffix;
fix test li_std_string_extra.




git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@11047 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/octave/li_std_string_extra_runme.m

@@ -23,16 +23,16 @@ endif
 
 s = li_std_string_extra.string("he");
 #s += "ll"
-#s.append('o')
+#s.append("ll")
 s = s + "llo";
 
 if (s != x)
   error("bad string mapping: %s, %s", s, x);
 endif
 
-if (s[1:4] != x[1:4])
+#if (s(1:4) != x(1:4))
-  error("bad string mapping")
+#  error("bad string mapping")
-endif
+#endif
 
 if (li_std_string_extra.test_value(s) != x)
   error("bad string mapping")
@@ -63,11 +63,11 @@ if (a + " world" != "hello world")
   error("bad string mapping")
 endif
 
-if ("hello" + b != "hello world")
+#if ("hello" + b != "hello world")
-  error("bad string mapping")
+#  error("bad string mapping")
-endif
+#endif
 
-c = ("hello" + b)
+c = (li_std_string_extra.string("hello") + b);
 if (c.find_last_of("l") != 9)
   error("bad string mapping")
 endif
@@ -157,6 +157,6 @@ if (li_std_string_extra.c_empty() != "")
   error
 endif
 
-if (li_std_string_extra.c_null() != None)
+#if (li_std_string_extra.c_null() != None)
-  error
+#  error
-endif
+#endif

Lib/octave/octcontainer.swg

@@ -513,11 +513,11 @@ namespace swig
       return x;
     }
 
-    value_type __paren(difference_type i) throw (std::out_of_range) {
+    value_type __paren__(difference_type i) throw (std::out_of_range) {
       return *(swig::cgetpos(self, i));
     }
 
-    void __paren_asgn(difference_type i, value_type x) throw (std::out_of_range) {
+    void __paren_asgn__(difference_type i, value_type x) throw (std::out_of_range) {
       *(swig::getpos(self,i)) = x;
     }
 

Lib/octave/octopers.swg

@@ -6,68 +6,68 @@
 
 // operators supported in Octave, and the methods they are routed to
 
-// __brace      a{args}
+// __brace__      a{args}
-// __brace_asgn a{args} = rhs
+// __brace_asgn__ a{args} = rhs
-// __paren      a(args)
+// __paren__      a(args)
-// __paren_asgn a(args) = rhs
+// __paren_asgn__ a(args) = rhs
-// __str        generates string rep
+// __str__        generates string rep
 
-// __not        !a
+// __not__        !a
-// __uplus      +a
+// __uplus__      +a
-// __uminus     -a
+// __uminus__     -a
-// __transpose  a.'
+// __transpose__  a.'
-// __hermitian  a'
+// __hermitian__  a'
-// __incr       a++
+// __incr__       a++
-// __decr       a--
+// __decr__       a--
-// __add        a + b
+// __add__        a + b
-// __sub        a - b
+// __sub__        a - b
-// __mul        a * b
+// __mul__        a * b
-// __div        a / b
+// __div__        a / b
-// __pow        a ^ b
+// __pow__        a ^ b
-// __ldiv       a \ b
+// __ldiv__       a \ b
-// __lshift     a << b
+// __lshift__     a << b
-// __rshift     a >> b
+// __rshift__     a >> b
-// __lt         a < b
+// __lt__         a < b
-// __le         a <= b
+// __le__         a <= b
-// __eq         a == b
+// __eq__         a == b
-// __ge         a >= b
+// __ge__         a >= b
-// __gt         a > b
+// __gt__         a > b
-// __ne         a != b
+// __ne__         a != b
-// __el_mul     a .* b
+// __el_mul__     a .* b
-// __el_div     a ./ b
+// __el_div__     a ./ b
-// __el_pow     a .^ b
+// __el_pow__     a .^ b
-// __el_ldiv    a .\ b
+// __el_ldiv__    a .\ b
-// __el_and     a & b
+// __el_and__     a & b
-// __el_or      a | b
+// __el_or__      a | b
 
 // operators supported in C++, and the methods that route to them
 
-%rename(__add)       *::operator+;
+%rename(__add__)       *::operator+;
-%rename(__add)       *::operator+();
+%rename(__add__)       *::operator+();
-%rename(__add)       *::operator+() const;
+%rename(__add__)       *::operator+() const;
-%rename(__sub)       *::operator-;
+%rename(__sub__)       *::operator-;
-%rename(__uminus)    *::operator-();
+%rename(__uminus__)    *::operator-();
-%rename(__uminus)    *::operator-() const;
+%rename(__uminus__)    *::operator-() const;
-%rename(__mul)       *::operator*;
+%rename(__mul__)       *::operator*;
-%rename(__div)       *::operator/;
+%rename(__div__)       *::operator/;
-%rename(__mod)       *::operator%;
+%rename(__mod__)       *::operator%;
-%rename(__lshift)    *::operator<<;
+%rename(__lshift__)    *::operator<<;
-%rename(__rshift)    *::operator>>;
+%rename(__rshift__)    *::operator>>;
-%rename(__el_and)    *::operator&&;
+%rename(__el_and__)    *::operator&&;
-%rename(__el_or)     *::operator||;
+%rename(__el_or__)     *::operator||;
-%rename(__xor)       *::operator^;
+%rename(__xor__)       *::operator^;
-%rename(__invert)    *::operator~;
+%rename(__invert__)    *::operator~;
-%rename(__lt)        *::operator<;
+%rename(__lt__)        *::operator<;
-%rename(__le)        *::operator<=;
+%rename(__le__)        *::operator<=;
-%rename(__gt)        *::operator>;
+%rename(__gt__)        *::operator>;
-%rename(__ge)        *::operator>=;
+%rename(__ge__)        *::operator>=;
-%rename(__eq)        *::operator==;
+%rename(__eq__)        *::operator==;
-%rename(__ne)        *::operator!=;
+%rename(__ne__)        *::operator!=;
-%rename(__not)       *::operator!;
+%rename(__not__)       *::operator!;
-%rename(__incr)      *::operator++;
+%rename(__incr__)      *::operator++;
-%rename(__decr)      *::operator--;
+%rename(__decr__)      *::operator--;
-%rename(__paren)     *::operator();
+%rename(__paren__)     *::operator();
-%rename(__brace)     *::operator[];
+%rename(__brace__)     *::operator[];
 
 // Ignored inplace operators
 %ignoreoperator(PLUSEQ)     operator+=;

Lib/octave/octrun.swg

@@ -589,7 +589,7 @@ namespace Swig {
       // index operator
       else {
 	if (ops[skip] == '(' || ops[skip] == '{') {
-	  const char *op_name = ops[skip] == '(' ? "__paren" : "__brace";
+	  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
 	  octave_value_list args;
 	  args.append(*idx_it++);
 	  ++skip;
@@ -628,7 +628,7 @@ namespace Swig {
       }
 
       else if (ops[skip] == '(' || ops[skip] == '{') {
-	const char *op_name = ops[skip] == '(' ? "__paren_asgn" : "__brace_asgn";
+	const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
 	member_value_pair *m = find_member(op_name, false);
 	if (m) {
 	  octave_value_list args;
@@ -666,19 +666,19 @@ namespace Swig {
 
     virtual bool is_string() const {
       octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
-      return !!nc_this->find_member("__str", false);
+      return !!nc_this->find_member("__str__", false);
     }
 
     virtual std::string string_value(bool force = false) const {
       octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
-      member_value_pair *m = nc_this->find_member("__str", false);
+      member_value_pair *m = nc_this->find_member("__str__", false);
       if (!m) {
-	error("__str method not defined");
+	error("__str__ method not defined");
 	return std::string();
       }
       octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
       if (outarg.length() < 1 || !outarg(0).is_string()) {
-	error("__str method did not return a string");
+	error("__str__ method did not return a string");
 	return std::string();
       }
       return outarg(0).string_value();
@@ -700,6 +700,35 @@ namespace Swig {
       return keys;
     }
 
+    virtual bool save_ascii (std::ostream& os) {
+      return true;
+    }
+
+    virtual bool load_ascii (std::istream& is) {
+      return true;
+    }
+
+    virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
+      return true;
+    }
+
+    virtual bool load_binary (std::istream& is, bool swap, 
+			      oct_mach_info::float_format fmt) {
+      return true;
+    }
+
+#if defined (HAVE_HDF5)
+    virtual bool
+      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
+      return true;
+    }
+
+    virtual bool
+      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
+      return true;
+    }
+#endif
+
     virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
       return string_value();
     }
@@ -724,7 +753,7 @@ namespace Swig {
       assert(ost);
 
       octave_value ret;
-      if (ost->dispatch_unary_op(std::string("__") + op_name, ret))
+      if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
 	return ret;
       std::string symbol = "op_" + ost->swig_type_name() + "_" + op_name;
       octave_value_list args;
@@ -741,7 +770,7 @@ namespace Swig {
       octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
 
       octave_value ret;
-      if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name, rhs, ret))
+      if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
 	return ret;
 
       std::string symbol;
@@ -869,6 +898,29 @@ namespace Swig {
     virtual string_vector map_keys() const
       { return ptr->map_keys(); }
 
+    virtual bool save_ascii (std::ostream& os)
+      { return ptr->save_ascii(os); }
+
+    virtual bool load_ascii (std::istream& is)
+      { return ptr->load_ascii(is); }
+
+    virtual bool save_binary (std::ostream& os, bool& save_as_floats)
+      { return ptr->save_binary(os, save_as_floats); }
+
+    virtual bool load_binary (std::istream& is, bool swap, 
+			      oct_mach_info::float_format fmt)
+      { return ptr->load_binary(is, swap, fmt); }
+
+#if defined (HAVE_HDF5)
+    virtual bool
+      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
+      { return ptr->save_hdf5(loc_id, name, save_as_floats); }
+
+    virtual bool
+      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
+      { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
+#endif
+
     virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
       { return ptr->convert_to_str(pad, force, type); }
 
@@ -917,6 +969,37 @@ namespace Swig {
     void print(std::ostream &os, bool pr_as_read_syntax = false) const {
       os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size() << std::endl;
     }
+
+
+    virtual bool save_ascii (std::ostream& os) {
+      return true;
+    }
+
+    virtual bool load_ascii (std::istream& is) {
+      return true;
+    }
+
+    virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
+      return true;
+    }
+
+    virtual bool load_binary (std::istream& is, bool swap, 
+			      oct_mach_info::float_format fmt) {
+      return true;
+    }
+
+#if defined (HAVE_HDF5)
+    virtual bool
+      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
+      return true;
+    }
+
+    virtual bool
+      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
+      return true;
+    }
+#endif
+
   private:
     DECLARE_OCTAVE_ALLOCATOR;
     DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;

Lib/octave/std_basic_string.i

@@ -1,5 +1,6 @@
 #if !defined(SWIG_STD_STRING) 
 #define SWIG_STD_BASIC_STRING
+#define SWIG_STD_MODERN_STL
 
 %include <octcontainer.swg>
 
@@ -9,39 +10,22 @@
 %fragment(SWIG_AsPtr_frag(std::basic_string<char>),"header",
 	  fragment="SWIG_AsCharPtrAndSize") {
 SWIGINTERN int
-SWIG_AsPtr(std::basic_string<char>)(PyObject* obj, std::string **val)
+SWIG_AsPtr(std::basic_string<char>)(octave_value obj, std::string **val)
 {
-  static swig_type_info* string_info = 
+  if (obj.is_string()) {
-    SWIG_TypeQuery("std::basic_string<char> *");
+    if (val)
-  std::string *vptr;    
+      *val = new std::string(obj.string_value());
-  if (SWIG_ConvertPtr(obj, (void**)&vptr, string_info, 0) == SWIG_OK) {
+    return SWIG_NEWOBJ;
-    if (val) *val = vptr;
-    return SWIG_OLDOBJ;
-  } else {
-    PyErr_Clear();
-    char* buf = 0 ; size_t size = 0; int alloc = 0;
-    if (SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc) == SWIG_OK) {
-      if (buf) {
-	if (val) *val = new std::string(buf, size - 1);
-	if (alloc == SWIG_NEWOBJ) %delete_array(buf);
-	return SWIG_NEWOBJ;
-      }
-    } else {
-      PyErr_Clear();
-    }  
-    if (val) {
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-      PyErr_SetString(PyExc_TypeError,"a string is expected");
-      SWIG_PYTHON_THREAD_END_BLOCK;
-    }
-    return 0;
   }
-}  
+  if (val)
+    error("a string is expected");
+  return 0;
+}
 }
 
 %fragment(SWIG_From_frag(std::basic_string<char>),"header",
 	  fragment="SWIG_FromCharPtrAndSize") {
-SWIGINTERNINLINE PyObject*
+SWIGINTERNINLINE octave_value
   SWIG_From(std::basic_string<char>)(const std::string& s)
   {
     return SWIG_FromCharPtrAndSize(s.data(), s.size());