# HG changeset patch
# User jwe
# Date 861413458 0
# Node ID 6285237ed3b9ac859050d34a259b0269209a197e
# Parent  c691fdf6bebb67637b21ef47cd09fea141283b32
[project @ 1997-04-19 01:30:58 by jwe]

diff --git a/src/oct-obj.cc b/src/oct-obj.cc
--- a/src/oct-obj.cc
+++ b/src/oct-obj.cc
@@ -31,8 +31,67 @@
 #include "error.h"
 #include "oct-obj.h"
 
-int
-octave_value_list::all_strings (void) const
+octave_value_list&
+octave_value_list::prepend (const octave_value& val)
+{
+  int n = length ();
+
+  resize (n + 1);
+
+  while (n > 0)
+    {
+      elem (n) = elem (n - 1);
+      n--;
+    }
+
+  elem (0) = val;
+  
+  return *this;
+}
+
+octave_value_list&
+octave_value_list::append (const octave_value& val)
+{
+  int n = length ();
+
+  resize (n + 1);
+
+  elem (n) = val;
+
+  return *this;
+}
+
+octave_value_list&
+octave_value_list::append (const octave_value_list& lst)
+{
+  int len = length ();
+  int lst_len = lst.length ();
+
+  resize (len + lst_len);
+
+  for (int i = 0; i < lst_len; i++)
+    elem (len + i) = lst (i);
+
+  return *this;
+}
+
+octave_value_list&
+octave_value_list::reverse (void)
+{
+  int n = length ();
+
+  for (int i = 0; i < n / 2; i++)
+    {
+      octave_value tmp = elem (i);
+      elem (i) = elem (n - i - 1);
+      elem (n - i - 1) = tmp;
+    }
+
+  return *this;
+}
+
+bool
+octave_value_list::all_strings_p (void) const
 {
   int n = length ();
 
@@ -48,7 +107,7 @@
 {
   string_vector argv;
 
-  if (all_strings ())
+  if (all_strings_p ())
     {
       int n = length ();
       argv.resize (n+1);
diff --git a/src/oct-obj.h b/src/oct-obj.h
--- a/src/oct-obj.h
+++ b/src/oct-obj.h
@@ -35,124 +35,135 @@
 #include "ov.h"
 
 class
-octave_value_list : public Array<octave_value>
+octave_value_list
 {
 public:
 
   octave_value_list (void)
-    : Array<octave_value> () { }
+    : data () { }
 
   octave_value_list (int n, const octave_value& val)
-    : Array<octave_value> (n, val) { }
+    : data (n, val) { }
 
   octave_value_list (const octave_value& tc)
-    : Array<octave_value> (1, tc) { }
+    : data (1, tc) { }
 
   octave_value_list (double d)
-    : Array<octave_value> (1, octave_value (d)) { }
+    : data (1, octave_value (d)) { }
 
   octave_value_list (const Matrix& m)
-    : Array<octave_value> (1, octave_value (m)) { }
+    : data (1, octave_value (m)) { }
 
   octave_value_list (const DiagMatrix& d)
-    : Array<octave_value> (1, octave_value (d)) { }
+    : data (1, octave_value (d)) { }
 
   octave_value_list (const RowVector& v, int pcv)
-    : Array<octave_value> (1, octave_value (v, pcv)) { }
+    : data (1, octave_value (v, pcv)) { }
 
   octave_value_list (const ColumnVector& v, int pcv)
-    : Array<octave_value> (1, octave_value (v, pcv)) { }
+    : data (1, octave_value (v, pcv)) { }
 
   octave_value_list (const Complex& c)
-    : Array<octave_value> (1, octave_value (c)) { }
+    : data (1, octave_value (c)) { }
 
   octave_value_list (const ComplexMatrix& m)
-    : Array<octave_value> (1, octave_value (m)) { }
+    : data (1, octave_value (m)) { }
 
   octave_value_list (const ComplexDiagMatrix& d)
-    : Array<octave_value> (1, octave_value (d)) { }
+    : data (1, octave_value (d)) { }
 
   octave_value_list (const ComplexRowVector& v, int pcv)
-    : Array<octave_value> (1, octave_value (v, pcv)) { }
+    : data (1, octave_value (v, pcv)) { }
 
   octave_value_list (const ComplexColumnVector& v, int pcv)
-    : Array<octave_value> (1, octave_value (v, pcv)) { }
+    : data (1, octave_value (v, pcv)) { }
 
   octave_value_list (const char *s)
-    : Array<octave_value> (1, octave_value (s)) { }
+    : data (1, octave_value (s)) { }
 
   octave_value_list (const string& s)
-    : Array<octave_value> (1, octave_value (s)) { }
+    : data (1, octave_value (s)) { }
 
   octave_value_list (const string_vector& s)
-    : Array<octave_value> (1, octave_value (s)) { }
+    : data (1, octave_value (s)) { }
 
   octave_value_list (double base, double limit, double inc)
-    : Array<octave_value> (1, octave_value (base, limit, inc)) { }
+    : data (1, octave_value (base, limit, inc)) { }
 
   octave_value_list (const Range& r)
-    : Array<octave_value> (1, octave_value (r)) { }
+    : data (1, octave_value (r)) { }
 
   octave_value_list (const octave_value_list& obj)
-    : Array<octave_value> (obj) { }
+    : data (obj.data) { }
 
   octave_value_list& operator = (const octave_value_list& obj)
     {
       if (this != &obj)
-	Array<octave_value>::operator = (obj);
+	data = obj.data;
 
       return *this;
     }
 
-// Assignment will resize on range errors.
+  // Assignment will resize on range errors.
 
   octave_value& operator () (int n) { return elem (n); }
 
   octave_value operator () (int n) const { return elem (n); }
 
-  int all_strings (void) const;
+  int length (void) const { return data.length (); }
+
+  void resize (int n) { data.resize (n); }
+
+  void resize (int n, const octave_value& val) { data.resize (n, val); }
+
+  octave_value_list& prepend (const octave_value& val);
+
+  octave_value_list& append (const octave_value& val);
+
+  octave_value_list& append (const octave_value_list& lst);
+
+  octave_value_list& reverse (void);
+
+  bool all_strings_p (void) const;
 
   string_vector make_argv (const string&) const;
 
 private:
 
-// This constructor is private with no definition to keep statements
-// like
-//
-//   octave_value_list foo = 5;
-//   octave_value_list foo = 5.0;
-//
-// from doing different things.  Instead, you have to use the
-// constructor
-//
-//   octave_value_list (n, val);
-//
-// and supply a default value to create a vector-valued octave_value_list.
+  Array<octave_value> data;
+
+  // This constructor is private with no definition to keep statements
+  // like
+  //
+  //   octave_value_list foo = 5;
+  //   octave_value_list foo = 5.0;
+  //
+  // from doing different things.  Instead, you have to use the
+  // constructor
+  //
+  //   octave_value_list (n, val);
+  //
+  // and supply a default value to create a vector-valued
+  // octave_value_list.
 
   octave_value_list (int n);
 
   void maybe_resize (int n)
     {
       if (n >= length ())
-	resize (n + 1, Matrix ());
+	data.resize (n + 1, Matrix ());
     }
 
   octave_value& elem (int n)
     {
       maybe_resize (n);
-      return Array<octave_value>::elem (n);
+      return data.elem (n);
     }
 
-  octave_value& checkelem (int n);
-
-  octave_value& xelem (int n);
-
   octave_value elem (int n) const
     {
-      return Array<octave_value>::operator () (n);
+      return data.elem (n);
     }
-
-  octave_value checkelem (int n) const;
 };
 
 #endif