Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #if !defined (octave_oct_obj_h)
00025 #define octave_oct_obj_h 1
00026
00027 #include <string>
00028 #include <vector>
00029
00030 #include "oct-alloc.h"
00031 #include "str-vec.h"
00032 #include "Array.h"
00033
00034 #include "ov.h"
00035 #include "Cell.h"
00036
00037 class
00038 OCTINTERP_API
00039 octave_value_list
00040 {
00041 public:
00042
00043 octave_value_list (void)
00044 : data (), names () { }
00045
00046 explicit octave_value_list (octave_idx_type n)
00047 : data (dim_vector (1, n)), names () { }
00048
00049 octave_value_list (octave_idx_type n, const octave_value& val)
00050 : data (dim_vector (1, n), val), names () { }
00051
00052 octave_value_list (const octave_value& tc)
00053 : data (dim_vector (1, 1), tc), names () { }
00054
00055 octave_value_list (const Array<octave_value>& d)
00056 : data (d.as_row ()), names () { }
00057
00058 octave_value_list (const Cell& tc)
00059 : data (tc.as_row ()), names () { }
00060
00061 octave_value_list (const octave_value_list& obj)
00062 : data (obj.data), names (obj.names) { }
00063
00064
00065 octave_value_list (const std::list<octave_value_list>&);
00066
00067 ~octave_value_list (void) { }
00068
00069 void *operator new (size_t size)
00070 { return allocator.alloc (size); }
00071
00072 void operator delete (void *p, size_t size)
00073 { allocator.free (p, size); }
00074
00075
00076
00077 void *operator new (size_t size, void *p)
00078 { return ::operator new (size, p); }
00079
00080 void operator delete (void *p, void *)
00081 {
00082 #if defined (HAVE_PLACEMENT_DELETE)
00083 ::operator delete (p, static_cast<void *> (0));
00084 #else
00085 ::operator delete (p);
00086 #endif
00087 }
00088
00089 octave_value_list& operator = (const octave_value_list& obj)
00090 {
00091 if (this != &obj)
00092 {
00093 data = obj.data;
00094 names = obj.names;
00095 }
00096
00097 return *this;
00098 }
00099
00100 Array<octave_value> array_value (void) const { return data; }
00101
00102 Cell cell_value (void) const { return array_value (); }
00103
00104
00105
00106 octave_value& operator () (octave_idx_type n) { return elem (n); }
00107
00108 const octave_value& operator () (octave_idx_type n) const { return elem (n); }
00109
00110 octave_idx_type length (void) const { return data.length (); }
00111
00112 bool empty (void) const { return length () == 0; }
00113
00114 void resize (octave_idx_type n, const octave_value& rfv
00115 = Array<octave_value>::resize_fill_value ())
00116 {
00117 data.resize (dim_vector (1, n), rfv);
00118 }
00119
00120 octave_value_list& prepend (const octave_value& val);
00121
00122 octave_value_list& append (const octave_value& val);
00123
00124 octave_value_list& append (const octave_value_list& lst);
00125
00126 octave_value_list& reverse (void);
00127
00128 octave_value_list
00129 slice (octave_idx_type offset, octave_idx_type len, bool tags = false) const
00130 {
00131 octave_value_list retval (data.linear_slice (offset, offset + len));
00132 if (tags && len > 0 && names.length () > 0)
00133 retval.names = names.linear_slice (offset, std::min (len, names.length ()));
00134
00135 return retval;
00136 }
00137
00138 octave_value_list
00139 splice (octave_idx_type offset, octave_idx_type len,
00140 const octave_value_list& lst = octave_value_list ()) const;
00141
00142 bool all_strings_p (void) const;
00143
00144 bool all_scalars (void) const;
00145
00146 bool any_cell (void) const;
00147
00148 bool has_magic_colon (void) const;
00149
00150 string_vector make_argv (const std::string& = std::string()) const;
00151
00152 void stash_name_tags (const string_vector& nm) { names = nm; }
00153
00154 string_vector name_tags (void) const { return names; }
00155
00156 void make_storable_values (void);
00157
00158 octave_value& xelem (octave_idx_type i)
00159 {
00160 return data.xelem (i);
00161 }
00162
00163 void clear (void)
00164 {
00165 data.clear ();
00166 }
00167
00168 private:
00169
00170 static octave_allocator allocator;
00171
00172 Array<octave_value> data;
00173
00174
00175
00176 string_vector names;
00177
00178 octave_value& elem (octave_idx_type n)
00179 {
00180 if (n >= length ())
00181 resize (n + 1);
00182
00183 return data(n);
00184 }
00185
00186 const octave_value& elem (octave_idx_type n) const
00187 { return data(n); }
00188 };
00189
00190 #endif