Mercurial > octave
diff libinterp/octave-value/ov-typeinfo.h @ 24540:46440078d73b
don't use singleton for octave_value_typeinfo
* ov-typeinfo.h, ov-typeinfo.cc (type_info): New class containing the
functionaity provided by the non-static functions in the
octave_value_typeinfo class. Define in octave namespace.
(octave_value_typeinfo): Now a namespace containing global functions
instead of a class containing all static functions. Provided for
backward compatibility, so all functions are tagged as deprecated.
* ops.h (INSTALL_UNOP_TI, INSTALL_NCUNOP_TI, INSTALL_BINOP_TI,
INSTALL_CATOP_TI, INSTALL_ASSIGNOP_TI, INSTALL_ASSIGNANYOP_TI,
INSTALL_ASSIGNCONV_TI, INSTALL_WIDENOP_TI): New macros.
(install_ops): Accept reference to type_info object as
an argument.
* mk-ops.sh: Generate function decls and calls that pass reference
to type_info object as an argument.
* op-b-b.cc, op-b-bm.cc, op-b-sbm.cc, op-bm-b.cc, op-bm-bm.cc,
op-bm-sbm.cc, op-cdm-cdm.cc, op-cell.cc, op-chm.cc, op-class.cc,
op-cm-cm.cc, op-cm-cs.cc, op-cm-m.cc, op-cm-s.cc, op-cm-scm.cc,
op-cm-sm.cc, op-cs-cm.cc, op-cs-cs.cc, op-cs-m.cc, op-cs-s.cc,
op-cs-scm.cc, op-cs-sm.cc, op-dm-dm.cc, op-dm-scm.cc, op-dm-sm.cc,
op-dm-template.cc, op-dms-template.cc, op-fcdm-fcdm.cc, op-fcm-fcm.cc,
op-fcm-fcs.cc, op-fcm-fm.cc, op-fcm-fs.cc, op-fcn.cc, op-fcs-fcm.cc,
op-fcs-fcs.cc, op-fcs-fm.cc, op-fcs-fs.cc, op-fdm-fdm.cc,
op-fm-fcm.cc, op-fm-fcs.cc, op-fm-fm.cc, op-fm-fs.cc, op-fs-fcm.cc,
op-fs-fcs.cc, op-fs-fm.cc, op-fs-fs.cc, op-i16-i16.cc, op-i32-i32.cc,
op-i64-i64.cc, op-i8-i8.cc, op-int-concat.cc, op-int.h, op-m-cm.cc,
op-m-cs.cc, op-m-m.cc, op-m-s.cc, op-m-scm.cc, op-m-sm.cc,
op-pm-pm.cc, op-pm-scm.cc, op-pm-sm.cc, op-pm-template.cc,
op-range.cc, op-s-cm.cc, op-s-cs.cc, op-s-m.cc, op-s-s.cc,
op-s-scm.cc, op-s-sm.cc, op-sbm-b.cc, op-sbm-bm.cc, op-sbm-sbm.cc,
op-scm-cm.cc, op-scm-cs.cc, op-scm-m.cc, op-scm-s.cc, op-scm-scm.cc,
op-scm-sm.cc, op-sm-cm.cc, op-sm-cs.cc, op-sm-m.cc, op-sm-s.cc,
op-sm-scm.cc, op-sm-sm.cc, op-str-m.cc, op-str-s.cc, op-str-str.cc,
op-struct.cc, op-ui16-ui16.cc, op-ui32-ui32.cc, op-ui64-ui64.cc,
op-ui8-ui8.cc): Use new _T1 macros. Update install_TYPE_ops function
for each type to accept reference to type_info object as argument.
* interpreter.h, interpreter.cc (interpreter::m_type_info):
New member variable.
(interpreter::get_type_info): New function.
(interpreter::interpreter): Initialize m_type_info before
m_symbol_table. Don't call install_types or install ops. That is now
handled by the in type_info constructor. Don't call m_cdef_manager.
That is now handled by the cdef_manager constructor.
* interpreter-private.h, interpreter-private.cc (__get_type_info__):
New function. Use where necessary to get reference to
interpreter::m_type_info object.
* ov-classdef.cc, ov-classdef.h (octave_classdef::octave_classdef):
Handle all initialization here.
(octave_classdef::initialize): Delete unused function.
* ov.h, ov.cc (install_types): Accept reference to type_info object as
argument. Pass on to individual register_type functions.
* ov-base.h, ov-base.cc (DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA): Update
to define additional register_type functions that accepts reference to
type_info object.
(install_base_type_conversions): Update to use new *_TI macros.
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Fri, 05 Jan 2018 18:44:53 -0500 |
| parents | 194eb4bd202b |
| children | 5f445419559f |
line wrap: on
line diff
--- a/libinterp/octave-value/ov-typeinfo.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-typeinfo.h Fri Jan 05 18:44:53 2018 -0500 @@ -34,296 +34,341 @@ class string_vector; -class -OCTINTERP_API -octave_value_typeinfo +namespace octave { -public: + class type_info + { + public: - typedef octave_value (*unary_class_op_fcn) (const octave_value&); + typedef octave_value (*unary_class_op_fcn) (const octave_value&); - typedef octave_value (*unary_op_fcn) (const octave_base_value&); + typedef octave_value (*unary_op_fcn) (const octave_base_value&); - typedef void (*non_const_unary_op_fcn) (octave_base_value&); + typedef void (*non_const_unary_op_fcn) (octave_base_value&); - typedef octave_value (*binary_class_op_fcn) + typedef octave_value (*binary_class_op_fcn) (const octave_value&, const octave_value&); - typedef octave_value (*binary_op_fcn) + typedef octave_value (*binary_op_fcn) (const octave_base_value&, const octave_base_value&); - typedef octave_value (*cat_op_fcn) + typedef octave_value (*cat_op_fcn) (octave_base_value&, const octave_base_value&, const Array<octave_idx_type>& ra_idx); - typedef octave_value (*assign_op_fcn) + typedef octave_value (*assign_op_fcn) (octave_base_value&, const octave_value_list&, const octave_base_value&); - typedef octave_value (*assignany_op_fcn) + typedef octave_value (*assignany_op_fcn) (octave_base_value&, const octave_value_list&, const octave_value&); - static bool instance_ok (void); + explicit type_info (int init_tab_sz = 16); - static int register_type (const std::string&, const std::string&, - const octave_value&); + // No copying! + + type_info (const type_info&) = delete; - static bool register_unary_class_op (octave_value::unary_op, - unary_class_op_fcn); + type_info& operator = (const type_info&) = delete; - static bool register_unary_op (octave_value::unary_op, int, unary_op_fcn); + ~type_info (void) = default; - static bool register_non_const_unary_op (octave_value::unary_op, int, - non_const_unary_op_fcn); + // It is intentional that there is no install_type function. - static bool register_binary_class_op (octave_value::binary_op, - binary_class_op_fcn); + bool install_unary_class_op (octave_value::unary_op op, + unary_class_op_fcn f) + { + return register_unary_class_op (op, f, true); + } - static bool register_binary_op (octave_value::binary_op, int, int, - binary_op_fcn); + bool install_unary_op (octave_value::unary_op op, int t, unary_op_fcn f) + { + return register_unary_op (op, t, f, true); + } - static bool register_binary_class_op (octave_value::compound_binary_op, - binary_class_op_fcn); + bool install_non_const_unary_op (octave_value::unary_op op, int t, + non_const_unary_op_fcn f) + { + return register_non_const_unary_op (op, t, f, true); + } - static bool register_binary_op (octave_value::compound_binary_op, int, int, - binary_op_fcn); - - static bool register_cat_op (int, int, cat_op_fcn); - - static bool register_assign_op (octave_value::assign_op, int, int, - assign_op_fcn); + bool install_binary_class_op (octave_value::binary_op op, + binary_class_op_fcn f) + { + return register_binary_class_op (op, f, true); + } - static bool register_assignany_op (octave_value::assign_op, int, - assignany_op_fcn); - - static bool register_pref_assign_conv (int, int, int); + bool install_binary_op (octave_value::binary_op op, int t1, int t2, + binary_op_fcn f) + { + return register_binary_op (op, t1, t2, f, true); + } - static bool - register_widening_op (int, int, octave_base_value::type_conv_fcn); + bool install_binary_class_op (octave_value::compound_binary_op op, + binary_class_op_fcn f) + { + return register_binary_class_op (op, f, true); + } - static octave_value - lookup_type (const std::string& nm) - { - return instance->do_lookup_type (nm); - } + bool install_binary_op (octave_value::compound_binary_op op, + int t_lhs, int t_rhs, binary_op_fcn f) + { + return register_binary_op (op, t_lhs, t_rhs, f, true); + } - static unary_class_op_fcn - lookup_unary_class_op (octave_value::unary_op op) - { - return instance->do_lookup_unary_class_op (op); - } + bool install_cat_op (int t1, int t2, cat_op_fcn f) + { + return register_cat_op (t1, t2, f, true); + } + + bool install_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs, assign_op_fcn f) + { + return register_assign_op (op, t_lhs, t_rhs, f, true); + } - static unary_op_fcn - lookup_unary_op (octave_value::unary_op op, int t) - { - return instance->do_lookup_unary_op (op, t); - } + bool install_assignany_op (octave_value::assign_op op, int t_lhs, + assignany_op_fcn f) + { + return register_assignany_op (op, t_lhs, f, true); + } - static non_const_unary_op_fcn - lookup_non_const_unary_op (octave_value::unary_op op, int t) - { - return instance->do_lookup_non_const_unary_op (op, t); - } + bool install_pref_assign_conv (int t_lhs, int t_rhs, int t_result) + { + return register_pref_assign_conv (t_lhs, t_rhs, t_result, true); + } - static binary_class_op_fcn - lookup_binary_class_op (octave_value::binary_op op) - { - return instance->do_lookup_binary_class_op (op); - } + bool install_widening_op (int t, int t_result, + octave_base_value::type_conv_fcn f) + { + return register_widening_op (t, t_result, f, true); + } + + int register_type (const std::string&, const std::string&, + const octave_value&, bool abort_on_duplicate = false); - static binary_op_fcn - lookup_binary_op (octave_value::binary_op op, int t1, int t2) - { - return instance->do_lookup_binary_op (op, t1, t2); - } + bool register_unary_class_op (octave_value::unary_op, unary_class_op_fcn, + bool abort_on_duplicate = false); + + bool register_unary_op (octave_value::unary_op, int, unary_op_fcn, + bool abort_on_duplicate = false); + + bool register_non_const_unary_op (octave_value::unary_op, int, + non_const_unary_op_fcn, + bool abort_on_duplicate = false); - static binary_class_op_fcn - lookup_binary_class_op (octave_value::compound_binary_op op) - { - return instance->do_lookup_binary_class_op (op); - } + bool register_binary_class_op (octave_value::binary_op, + binary_class_op_fcn, + bool abort_on_duplicate = false); + + bool register_binary_op (octave_value::binary_op, int, int, + binary_op_fcn, bool abort_on_duplicate = false); - static binary_op_fcn - lookup_binary_op (octave_value::compound_binary_op op, int t1, int t2) - { - return instance->do_lookup_binary_op (op, t1, t2); - } + bool register_binary_class_op (octave_value::compound_binary_op, + binary_class_op_fcn, + bool abort_on_duplicate = false); - static cat_op_fcn - lookup_cat_op (int t1, int t2) - { - return instance->do_lookup_cat_op (t1, t2); - } + bool register_binary_op (octave_value::compound_binary_op, int, int, + binary_op_fcn, bool abort_on_duplicate = false); + + bool register_cat_op (int, int, cat_op_fcn, + bool abort_on_duplicate = false); + + bool register_assign_op (octave_value::assign_op, int, int, assign_op_fcn, + bool abort_on_duplicate = false); - static assign_op_fcn - lookup_assign_op (octave_value::assign_op op, int t_lhs, int t_rhs) - { - return instance->do_lookup_assign_op (op, t_lhs, t_rhs); - } + bool register_assignany_op (octave_value::assign_op, int, assignany_op_fcn, + bool abort_on_duplicate = false); + + bool register_pref_assign_conv (int, int, int, + bool abort_on_duplicate = false); + + bool register_widening_op (int, int, octave_base_value::type_conv_fcn, + bool abort_on_duplicate = false); - static assignany_op_fcn - lookup_assignany_op (octave_value::assign_op op, int t_lhs) - { - return instance->do_lookup_assignany_op (op, t_lhs); - } + octave_value lookup_type (const std::string& nm); + + unary_class_op_fcn lookup_unary_class_op (octave_value::unary_op); - static int - lookup_pref_assign_conv (int t_lhs, int t_rhs) - { - return instance->do_lookup_pref_assign_conv (t_lhs, t_rhs); - } + unary_op_fcn lookup_unary_op (octave_value::unary_op, int); + + non_const_unary_op_fcn + lookup_non_const_unary_op (octave_value::unary_op, int); + + binary_class_op_fcn lookup_binary_class_op (octave_value::binary_op); - static octave_base_value::type_conv_fcn - lookup_widening_op (int t, int t_result) - { - return instance->do_lookup_widening_op (t, t_result); - } + binary_op_fcn lookup_binary_op (octave_value::binary_op, int, int); + + binary_class_op_fcn + lookup_binary_class_op (octave_value::compound_binary_op); + + binary_op_fcn + lookup_binary_op (octave_value::compound_binary_op, int, int); + + cat_op_fcn lookup_cat_op (int, int); - static string_vector installed_type_names (void) - { - return instance->do_installed_type_names (); - } + assign_op_fcn lookup_assign_op (octave_value::assign_op, int, int); + + assignany_op_fcn lookup_assignany_op (octave_value::assign_op, int); - static octave_scalar_map installed_type_info (void) - { - return instance->do_installed_type_info (); - } + int lookup_pref_assign_conv (int, int); -protected: + octave_base_value::type_conv_fcn lookup_widening_op (int, int); + + string_vector installed_type_names (void) const; - octave_value_typeinfo (void) - : num_types (0), types (dim_vector (init_tab_sz, 1), ""), - vals (dim_vector (init_tab_sz, 1)), - unary_class_ops (dim_vector (octave_value::num_unary_ops, 1), nullptr), - unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr), - non_const_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr), - binary_class_ops (dim_vector (octave_value::num_binary_ops, 1), nullptr), - binary_ops (dim_vector (octave_value::num_binary_ops, init_tab_sz, init_tab_sz), nullptr), - compound_binary_class_ops (dim_vector (octave_value::num_compound_binary_ops, 1), nullptr), - compound_binary_ops (dim_vector (octave_value::num_compound_binary_ops, init_tab_sz, init_tab_sz), nullptr), - cat_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr), - assign_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz, init_tab_sz), nullptr), - assignany_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz), nullptr), - pref_assign_conv (dim_vector (init_tab_sz, init_tab_sz), -1), - widening_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr) { } + octave_scalar_map installed_type_info (void) const; + + octave_scalar_map unary_ops_map (void) const; + + octave_scalar_map non_const_unary_ops_map (void) const; + + octave_scalar_map binary_ops_map (void) const; + + octave_scalar_map compound_binary_ops_map (void) const; + + octave_scalar_map assign_ops_map (void) const; + + octave_scalar_map assignany_ops_map (void) const; + + private: + + int num_types; - // No copying! + Array<std::string> types; - octave_value_typeinfo (const octave_value_typeinfo&) = delete; + Array<octave_value> vals; - octave_value_typeinfo& operator = (const octave_value_typeinfo&) = delete; + Array<void *> unary_class_ops; - ~octave_value_typeinfo (void) = default; + Array<void *> unary_ops; -private: + Array<void *> non_const_unary_ops; - static const int init_tab_sz; + Array<void *> binary_class_ops; - static octave_value_typeinfo *instance; + Array<void *> binary_ops; - static void cleanup_instance (void) { delete instance; instance = nullptr; } + Array<void *> compound_binary_class_ops; + + Array<void *> compound_binary_ops; - int num_types; + Array<void *> cat_ops; - Array<std::string> types; + Array<void *> assign_ops; - Array<octave_value> vals; + Array<void *> assignany_ops; - Array<void *> unary_class_ops; + Array<int> pref_assign_conv; - Array<void *> unary_ops; - - Array<void *> non_const_unary_ops; + Array<void *> widening_ops; + }; +} - Array<void *> binary_class_ops; +namespace octave_value_typeinfo +{ + typedef octave::type_info::unary_class_op_fcn unary_class_op_fcn; - Array<void *> binary_ops; + typedef octave::type_info::unary_op_fcn unary_op_fcn; - Array<void *> compound_binary_class_ops; + typedef octave::type_info::non_const_unary_op_fcn non_const_unary_op_fcn; - Array<void *> compound_binary_ops; + typedef octave::type_info::binary_class_op_fcn binary_class_op_fcn; - Array<void *> cat_ops; + typedef octave::type_info::binary_op_fcn binary_op_fcn; - Array<void *> assign_ops; + typedef octave::type_info::cat_op_fcn cat_op_fcn; + + typedef octave::type_info::assign_op_fcn assign_op_fcn; - Array<void *> assignany_ops; - - Array<int> pref_assign_conv; + typedef octave::type_info::assignany_op_fcn assignany_op_fcn; - Array<void *> widening_ops; + extern int register_type (const std::string& t_name, + const std::string& c_name, + const octave_value& val); - int do_register_type (const std::string&, const std::string&, - const octave_value&); - - bool do_register_unary_class_op (octave_value::unary_op, unary_class_op_fcn); + OCTAVE_DEPRECATED(4.4, "use octave::type_info::register_unary_class_op instead") + extern bool register_unary_class_op (octave_value::unary_op op, + unary_class_op_fcn f); - bool do_register_unary_op (octave_value::unary_op, int, unary_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_unary_op instead") + extern bool register_unary_op (octave_value::unary_op op, + int t, unary_op_fcn f); - bool do_register_non_const_unary_op (octave_value::unary_op, int, - non_const_unary_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_non_const_unary_op instead") + extern bool register_non_const_unary_op (octave_value::unary_op op, + int t, non_const_unary_op_fcn f); - bool do_register_binary_class_op (octave_value::binary_op, - binary_class_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_class_op instead") + extern bool register_binary_class_op (octave_value::binary_op op, + binary_class_op_fcn f); - bool do_register_binary_op (octave_value::binary_op, int, int, - binary_op_fcn); - - bool do_register_binary_class_op (octave_value::compound_binary_op, - binary_class_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_op instead") + extern bool register_binary_op (octave_value::binary_op op, + int t1, int t2, binary_op_fcn f); - bool do_register_binary_op (octave_value::compound_binary_op, int, int, - binary_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_class_op instead") + extern bool register_binary_class_op (octave_value::compound_binary_op op, + binary_class_op_fcn f); - bool do_register_cat_op (int, int, cat_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_op instead") + extern bool register_binary_op (octave_value::compound_binary_op op, + int t1, int t2, binary_op_fcn f); - bool do_register_assign_op (octave_value::assign_op, int, int, - assign_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_cat_op instead") + extern bool register_cat_op (int t1, int t2, cat_op_fcn f); - bool do_register_assignany_op (octave_value::assign_op, int, - assignany_op_fcn); - - bool do_register_pref_assign_conv (int, int, int); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_assign_op instead") + extern bool register_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs, assign_op_fcn f); - bool do_register_widening_op (int, int, octave_base_value::type_conv_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_assignany_op instead") + extern bool register_assignany_op (octave_value::assign_op op, + int t_lhs, assignany_op_fcn f); - octave_value do_lookup_type (const std::string& nm); - - unary_class_op_fcn do_lookup_unary_class_op (octave_value::unary_op); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_pref_assign_conv instead") + extern bool register_pref_assign_conv (int t_lhs, int t_rhs, int t_result); - unary_op_fcn do_lookup_unary_op (octave_value::unary_op, int); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_widening_op instead") + extern bool register_widening_op (int t, int t_result, + octave_base_value::type_conv_fcn f); - non_const_unary_op_fcn do_lookup_non_const_unary_op - (octave_value::unary_op, int); + extern octave_value lookup_type (const std::string& nm); - binary_class_op_fcn do_lookup_binary_class_op (octave_value::binary_op); - - binary_op_fcn do_lookup_binary_op (octave_value::binary_op, int, int); + extern unary_class_op_fcn lookup_unary_class_op (octave_value::unary_op op); - binary_class_op_fcn do_lookup_binary_class_op (octave_value::compound_binary_op); + extern unary_op_fcn lookup_unary_op (octave_value::unary_op op, int t); + + extern non_const_unary_op_fcn + lookup_non_const_unary_op (octave_value::unary_op op, int t); - binary_op_fcn do_lookup_binary_op (octave_value::compound_binary_op, - int, int); + extern binary_class_op_fcn + lookup_binary_class_op (octave_value::binary_op op); - cat_op_fcn do_lookup_cat_op (int, int); - - assign_op_fcn do_lookup_assign_op (octave_value::assign_op, int, int); + extern binary_op_fcn + lookup_binary_op (octave_value::binary_op op, int t1, int t2); - assignany_op_fcn do_lookup_assignany_op (octave_value::assign_op, int); - - int do_lookup_pref_assign_conv (int, int); + extern binary_class_op_fcn + lookup_binary_class_op (octave_value::compound_binary_op op); - octave_base_value::type_conv_fcn do_lookup_widening_op (int, int); + extern binary_op_fcn + lookup_binary_op (octave_value::compound_binary_op op, int t1, int t2); - string_vector do_installed_type_names (void) const; + extern cat_op_fcn lookup_cat_op (int t1, int t2); + + extern assign_op_fcn + lookup_assign_op (octave_value::assign_op op, int t_lhs, int t_rhs); - octave_scalar_map do_installed_type_info (void) const; + extern assignany_op_fcn + lookup_assignany_op (octave_value::assign_op op, int t_lhs); + + extern int lookup_pref_assign_conv (int t_lhs, int t_rhs); - octave_scalar_map unary_ops_map (void) const; - octave_scalar_map non_const_unary_ops_map (void) const; - octave_scalar_map binary_ops_map (void) const; - octave_scalar_map compound_binary_ops_map (void) const; - octave_scalar_map assign_ops_map (void) const; - octave_scalar_map assignany_ops_map (void) const; -}; + extern octave_base_value::type_conv_fcn + lookup_widening_op (int t, int t_result); + + extern string_vector installed_type_names (void); + + extern octave_scalar_map installed_type_info (void); +} #endif