-/* ------------------------------------------------\r
-Copyright 2014 AT&T Intellectual Property\r
- Licensed under the Apache License, Version 2.0 (the "License");\r
- you may not use this file except in compliance with the License.\r
- You may obtain a copy of the License at\r
-\r
- http://www.apache.org/licenses/LICENSE-2.0\r
-\r
- Unless required by applicable law or agreed to in writing, software\r
- distributed under the License is distributed on an "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- See the License for the specific language governing permissions and\r
- limitations under the License.\r
- ------------------------------------------- */\r
-#ifndef __TYPE_OBJECTS_H_DEFINED__\r
-#define __TYPE_OBJECTS_H_DEFINED__\r
-\r
-#include <string>\r
-#include<vector>\r
-\r
-#include"literal_types.h"\r
-#include"parse_schema.h"\r
-#include"type_indicators.h"\r
-#include"gstypes.h"\r
-#include"vstring.h"\r
-\r
-enum dtype {u_int_t, int_t, u_llong_t, llong_t, u_short_t, floating_t,\r
- bool_t, v_str_t, timeval_t, ip_t, ipv6_t, fstring_t, undefined_t};\r
-\r
-enum temporal_type {increasing_t, decreasing_t, constant_t, varying_t};\r
- // varying_t means I don't know.\r
- // constant_t MUST MEAN THAT ALL VALUES IN THE SE TREE ARE LITERALS!\r
-\r
-\r
-class data_type{\r
-private:\r
- std::string schema_type; // String representation of the data type.\r
- dtype type; // Internal representation of the data type.\r
- std::string subtype; // specialization of the type.\r
- // use to restrict access and provide annotation\r
- temporal_type temporal; // How does the value change over time.\r
- int size; // # bytes, it it can't be readily determined\r
-\r
- void assign_schema_type();\r
- void assign_type_from_string(std::string st);\r
-\r
-public:\r
- data_type(){type = undefined_t; assign_schema_type(); size=0; temporal=varying_t;};\r
- data_type(std::string st);\r
- data_type(std::string st, param_list *modifiers);\r
- data_type(int it);\r
- data_type(data_type *lhs, std::string &op);\r
- data_type(data_type *lhs, data_type *rhs, const std::string &op);\r
-\r
- static temporal_type compute_temporal_type(temporal_type l_tempo, std::string &op);\r
- static temporal_type compute_temporal_type(temporal_type l_tempo, temporal_type r_tempo, dtype l_type, dtype r_type, const std::string &op);\r
-\r
- data_type *duplicate();\r
- field_entry *make_field_entry(std::string n);\r
-\r
- void set_aggr_data_type(const std::string &op, data_type *dt);\r
-\r
- int type_indicator();\r
-\r
- dtype get_type(){return type; };\r
- std::string get_type_str(){return schema_type; };\r
- std::string to_string();\r
-\r
- temporal_type get_temporal(){return temporal; };\r
- void set_temporal(temporal_type t){temporal = t; };\r
- void reset_temporal(){ if(this->is_temporal()) temporal = varying_t;};\r
- bool is_temporal(){return( temporal == increasing_t || temporal == decreasing_t);};\r
- bool is_increasing(){return( temporal == increasing_t );};\r
- bool is_decreasing(){return( temporal == decreasing_t );};\r
-\r
- std::string get_temporal_string();\r
- std::vector<std::string> get_param_keys();\r
- std::string get_param_val(std::string k);\r
-\r
- bool is_defined(){return(type != undefined_t); };\r
-\r
- bool is_comparable(data_type *rhs, std::string op);\r
-\r
- std::string get_CC_accessor_type();\r
- std::string get_cvar_type();\r
- std::string get_tuple_cvar_type();\r
- std::string make_cvar(std::string v);\r
- std::string make_tuple_cvar(std::string v);\r
- std::string get_host_cvar_type();\r
- std::string make_host_cvar(std::string v);\r
- std::string make_host_tuple_cvar(std::string v);\r
- std::string get_hfta_unpack_fcn();\r
- std::string get_hfta_unpack_fcn_noxf();\r
-\r
- bool complex_comparison(data_type *dt);\r
- std::string get_comparison_fcn(data_type *dt);\r
- std::string get_hfta_comparison_fcn(data_type *dt);\r
-\r
- bool complex_operator(data_type *dt, std::string &op);\r
- std::string get_complex_operator(data_type *dt, std::string &op);\r
-\r
- bool complex_operator(std::string &op);\r
- std::string get_complex_operator(std::string &op);\r
-\r
- bool use_hashfunc();\r
- std::string get_hfta_hashfunc();\r
-\r
- bool needs_hn_translation();\r
- std::string hton_translation();\r
- std::string ntoh_translation();\r
-\r
- bool is_buffer_type();\r
-// LFTA functions\r
- std::string get_buffer_assign_copy();\r
- std::string get_buffer_tuple_copy();\r
- std::string get_buffer_replace();\r
- std::string get_buffer_size();\r
- std::string get_buffer_destroy();\r
-// HFTA functions\r
- std::string get_hfta_buffer_assign_copy();\r
- std::string get_hfta_buffer_tuple_copy();\r
- std::string get_hfta_buffer_replace();\r
- std::string get_hfta_buffer_size();\r
- std::string get_hfta_buffer_destroy();\r
-\r
- bool is_structured_type();\r
-// std::string get_interface_type();\r
-\r
-// These functions are obsolete\r
- std::string handle_registration_name();\r
- std::string hfta_handle_registration_name();\r
- std::string get_handle_destructor();\r
-\r
- bool fta_legal_type();\r
- static bool fta_legal_operation(data_type *lhs, data_type *rhs, std::string &op);\r
- static bool fta_legal_operation(data_type *lhs, std::string &op);\r
-\r
-// for schemaparser\r
- int type_size();\r
-\r
-/*\r
-// for external functions and predicates\r
-bool call_compatible(data_type *o);\r
-\r
-// test for equality : used by bind_to_schema and by testing for\r
-// mergability.\r
-bool equal(data_type *o);\r
-*/\r
-\r
- bool subsumes_type(data_type *o);\r
- bool equals(data_type *o);\r
- bool equal_subtypes(data_type *o);\r
-\r
-// literals corresponding to minimum and maximum values\r
- std::string get_min_literal();\r
- std::string get_max_literal();\r
-\r
-\r
-};\r
-\r
-\r
-#endif\r
+/* ------------------------------------------------
+Copyright 2014 AT&T Intellectual Property
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ ------------------------------------------- */
+#ifndef __TYPE_OBJECTS_H_DEFINED__
+#define __TYPE_OBJECTS_H_DEFINED__
+
+#include <string>
+#include<vector>
+
+#include"literal_types.h"
+#include"parse_schema.h"
+#include"type_indicators.h"
+#include"gstypes.h"
+#include"vstring.h"
+
+enum dtype {u_int_t, int_t, u_llong_t, llong_t, u_short_t, floating_t,
+ bool_t, v_str_t, timeval_t, ip_t, ipv6_t, fstring_t, undefined_t};
+
+enum temporal_type {increasing_t, decreasing_t, constant_t, varying_t};
+ // varying_t means I don't know.
+ // constant_t MUST MEAN THAT ALL VALUES IN THE SE TREE ARE LITERALS!
+
+
+class data_type{
+private:
+ std::string schema_type; // String representation of the data type.
+ dtype type; // Internal representation of the data type.
+ std::string subtype; // specialization of the type.
+ // use to restrict access and provide annotation
+ temporal_type temporal; // How does the value change over time.
+ int size; // # bytes, it it can't be readily determined
+
+ void assign_schema_type();
+ void assign_type_from_string(std::string st);
+
+public:
+ data_type(){type = undefined_t; assign_schema_type(); size=0; temporal=varying_t;};
+ data_type(std::string st);
+ data_type(std::string st, param_list *modifiers);
+ data_type(int it);
+ data_type(data_type *lhs, std::string &op);
+ data_type(data_type *lhs, data_type *rhs, const std::string &op);
+
+ static temporal_type compute_temporal_type(temporal_type l_tempo, std::string &op);
+ static temporal_type compute_temporal_type(temporal_type l_tempo, temporal_type r_tempo, dtype l_type, dtype r_type, const std::string &op);
+
+ data_type *duplicate();
+ field_entry *make_field_entry(std::string n);
+
+ void set_aggr_data_type(const std::string &op, data_type *dt);
+
+ int type_indicator();
+
+ dtype get_type(){return type; };
+ std::string get_type_str(){return schema_type; };
+ std::string to_string();
+
+ temporal_type get_temporal(){return temporal; };
+ void set_temporal(temporal_type t){temporal = t; };
+ void reset_temporal(){ if(this->is_temporal()) temporal = varying_t;};
+ bool is_temporal(){return( temporal == increasing_t || temporal == decreasing_t);};
+ bool is_increasing(){return( temporal == increasing_t );};
+ bool is_decreasing(){return( temporal == decreasing_t );};
+
+ std::string get_temporal_string();
+ std::vector<std::string> get_param_keys();
+ std::string get_param_val(std::string k);
+
+ bool is_defined(){return(type != undefined_t); };
+
+ bool is_comparable(data_type *rhs, std::string op);
+
+ std::string get_CC_accessor_type();
+ std::string get_cvar_type();
+ std::string get_tuple_cvar_type();
+ std::string make_cvar(std::string v);
+ std::string make_tuple_cvar(std::string v);
+ std::string get_host_cvar_type();
+ std::string make_host_cvar(std::string v);
+ std::string make_host_tuple_cvar(std::string v);
+ std::string get_hfta_unpack_fcn();
+ std::string get_hfta_unpack_fcn_noxf();
+
+ bool complex_comparison(data_type *dt);
+ std::string get_comparison_fcn(data_type *dt);
+ std::string get_hfta_comparison_fcn(data_type *dt);
+
+ bool complex_operator(data_type *dt, std::string &op);
+ std::string get_complex_operator(data_type *dt, std::string &op);
+
+ bool complex_operator(std::string &op);
+ std::string get_complex_operator(std::string &op);
+
+ bool use_hashfunc();
+ std::string get_hfta_hashfunc();
+
+ bool needs_hn_translation();
+ std::string hton_translation();
+ std::string ntoh_translation();
+
+ bool is_buffer_type();
+// LFTA functions
+ std::string get_buffer_assign_copy();
+ std::string get_buffer_tuple_copy();
+ std::string get_buffer_replace();
+ std::string get_buffer_size();
+ std::string get_buffer_destroy();
+// HFTA functions
+ std::string get_hfta_buffer_assign_copy();
+ std::string get_hfta_buffer_tuple_copy();
+ std::string get_hfta_buffer_replace();
+ std::string get_hfta_buffer_size();
+ std::string get_hfta_buffer_destroy();
+
+ bool is_structured_type();
+// std::string get_interface_type();
+
+// These functions are obsolete
+ std::string handle_registration_name();
+ std::string hfta_handle_registration_name();
+ std::string get_handle_destructor();
+
+ bool fta_legal_type();
+ static bool fta_legal_operation(data_type *lhs, data_type *rhs, std::string &op);
+ static bool fta_legal_operation(data_type *lhs, std::string &op);
+
+// for schemaparser
+ int type_size();
+
+/*
+// for external functions and predicates
+bool call_compatible(data_type *o);
+
+// test for equality : used by bind_to_schema and by testing for
+// mergability.
+bool equal(data_type *o);
+*/
+
+ bool subsumes_type(data_type *o);
+ bool equals(data_type *o);
+ bool equal_subtypes(data_type *o);
+
+// literals corresponding to minimum and maximum values
+ std::string get_min_literal();
+ std::string get_max_literal();
+
+// char* to X functions
+ std::string get_wl_extract_fcn();
+
+
+};
+
+
+#endif