src/ftacmp/type_objects.cc

   1 /* ------------------------------------------------
   2 Copyright 2014 AT&T Intellectual Property
   3    Licensed under the Apache License, Version 2.0 (the "License");
   4    you may not use this file except in compliance with the License.
   5    You may obtain a copy of the License at
   6
   7      http://www.apache.org/licenses/LICENSE-2.0
   8
   9    Unless required by applicable law or agreed to in writing, software
  10    distributed under the License is distributed on an "AS IS" BASIS,
  11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12    See the License for the specific language governing permissions and
  13    limitations under the License.
  14  ------------------------------------------- */
  15
  16 #include"type_objects.h"
  17
  18 #include <stdio.h>
  19
  20 using namespace std;
  21
  22 void data_type::assign_schema_type(){
  23         char tmps[100];
  24         switch(type){
  25         case bool_t:
  26                 schema_type = "BOOL";
  27                 break;
  28         case u_short_t:
  29                 schema_type = "USHORT";
  30                 break;
  31         case u_int_t:
  32                 schema_type = "UINT";
  33                 break;
  34         case int_t:
  35                 schema_type = "INT";
  36                 break;
  37         case u_llong_t:
  38                 schema_type = "ULLONG";
  39                 break;
  40         case llong_t:
  41                 schema_type = "LLONG";
  42                 break;
  43         case floating_t:
  44                 schema_type = "FLOAT";
  45                 break;
  46         case v_str_t:
  47                 schema_type = "V_STR";
  48                 break;
  49         case timeval_t:
  50                 schema_type = "TIMEVAL";
  51                 break;
  52         case ip_t:
  53                 schema_type = "IP";
  54                 break;
  55         case ipv6_t:
  56                 schema_type = "IPV6";
  57                 break;
  58         case fstring_t:
  59                 sprintf(tmps,"FSTRING%d",size);
  60                 schema_type = tmps;
  61                 break;
  62         default:
  63                 schema_type = "UNDEFINED_TYPE";
  64                 break;
  65         }
  66 }
  67
  68
  69 data_type::data_type(string st){
  70         size=0;
  71         temporal = varying_t;
  72         subtype = "";
  73         assign_type_from_string(st);
  74 }
  75
  76
  77 //              Assign data type of a colref using information about
  78 //              modifiers as well as data type.  This should be made robust.
  79 data_type::data_type(string st, param_list *modifiers){
  80         size=0;
  81         temporal = varying_t;
  82         subtype="";
  83         assign_type_from_string(st);
  84
  85     if(modifiers != NULL){
  86                 int i;
  87                 for(i=0;i<modifiers->size();i++){
  88                         if(     modifiers->contains_key("increasing") ||
  89                                 modifiers->contains_key("Increasing") ||
  90                                 modifiers->contains_key("INCREASING")){
  91                                         temporal = increasing_t;
  92                         }
  93                         if(     modifiers->contains_key("decreasing") ||
  94                                 modifiers->contains_key("Decreasing") ||
  95                                 modifiers->contains_key("DECREASING")){
  96                                         temporal = decreasing_t;
  97                         }
  98                         if(modifiers->contains_key("subtype")){
  99                                 subtype = modifiers->val_of("subtype");
 100                         }
 101                 }
 102         }
 103 }
 104
 105
 106 void data_type::assign_type_from_string(string st){
 107         if(st == "bool" || st == "Bool" || st == "BOOL"){
 108                 type = bool_t;
 109                 assign_schema_type();
 110                 return;
 111         }
 112         if(st == "ushort" || st == "Ushort" || st == "USHORT"){
 113                 type = u_short_t;
 114                 assign_schema_type();
 115                 return;
 116         }
 117         if(st == "uint" || st == "Uint" || st == "UINT"){
 118                 type = u_int_t;
 119                 assign_schema_type();
 120                 return;
 121         }
 122         if(st == "int" || st == "Int" || st == "INT"){
 123                 type = int_t;
 124                 assign_schema_type();
 125                 return;
 126         }
 127         if(st == "ullong" || st == "Ullong" || st == "ULLONG"){
 128                 type = u_llong_t;
 129                 assign_schema_type();
 130                 return;
 131         }
 132         if(st == "llong" || st == "llong" || st == "LLONG"){
 133                 type = llong_t;
 134                 assign_schema_type();
 135                 return;
 136         }
 137         if(st == "float" || st == "Float" || st == "FLOAT"){
 138                 type = floating_t;
 139                 assign_schema_type();
 140                 return;
 141         }
 142         if(st == "string" || st == "String" || st == "STRING" ||
 143                 st == "v_str" || st == "V_str" || st == "V_STR"){
 144                 type = v_str_t;
 145                 assign_schema_type();
 146                 return;
 147         }
 148         if(st == "timeval" || st == "Timeval" || st == "TIMEVAL"){
 149                 type = timeval_t;
 150                 assign_schema_type();
 151                 return;
 152         }
 153         if(st == "IP"){
 154                 type = ip_t;
 155                 assign_schema_type();
 156                 return;
 157         }
 158         if(st == "IPV6" || st == "IPv6"){
 159                 type = ipv6_t;
 160                 assign_schema_type();
 161                 return;
 162         }
 163         if(sscanf(st.c_str(),"fstring%d",&size)>0){
 164                 type = fstring_t;
 165                 assign_schema_type();
 166                 return;
 167         }
 168         if(sscanf(st.c_str(),"Fstring%d",&size)>0){
 169                 type = fstring_t;
 170                 assign_schema_type();
 171                 return;
 172         }
 173         if(sscanf(st.c_str(),"FSTRING%d",&size)>0){
 174                 type = fstring_t;
 175                 assign_schema_type();
 176                 return;
 177         }
 178
 179         type = undefined_t;
 180         assign_schema_type();
 181 }
 182
 183
 184 data_type::data_type(data_type *lhs, string &op){
 185
 186 //  type = undefined_t;
 187 //  temporal_type l_tempo = lhs->get_temporal();;
 188 //  if(l_tempo == constant_t) temporal = constant_t;
 189 //  else temporal = varying_t;
 190         size=0;
 191         temporal = compute_temporal_type(lhs->get_temporal(),op);
 192
 193   if(op == "-"){
 194         switch(lhs->get_type()){
 195         case int_t:
 196                 type = int_t;
 197                 break;
 198         case u_int_t:
 199         case u_short_t:
 200                 type = int_t;
 201 //              if(l_tempo == increasing_t) temporal = decreasing_t;
 202 //              if(l_tempo == decreasing_t) temporal = increasing_t;
 203                 break;
 204         case u_llong_t:
 205         case llong_t:
 206                 type = llong_t;
 207 //              if(l_tempo == increasing_t) temporal = decreasing_t;
 208 //              if(l_tempo == decreasing_t) temporal = increasing_t;
 209                 break;
 210         case floating_t:
 211                 type = floating_t;
 212 //              if(l_tempo == increasing_t) temporal = decreasing_t;
 213 //              if(l_tempo == decreasing_t) temporal = increasing_t;
 214                 break;
 215         default:
 216                 break;
 217         }
 218   }
 219
 220   if(op == "!"){
 221         switch(lhs->get_type()){
 222         case int_t:
 223         case u_int_t:
 224         case u_short_t:
 225         case u_llong_t:
 226         case llong_t:
 227         case bool_t:
 228         case ip_t:
 229                 type = lhs->get_type();
 230                 break;
 231         default:
 232                 break;
 233         }
 234   }
 235
 236   if(op == "~"){
 237         switch(lhs->get_type()){
 238         case int_t:
 239         case u_int_t:
 240         case u_short_t:
 241         case u_llong_t:
 242         case llong_t:
 243         case ip_t:
 244                 type = lhs->get_type();
 245                 break;
 246         default:
 247                 break;
 248         }
 249   }
 250
 251   subtype = lhs->subtype;
 252   assign_schema_type();
 253 }
 254
 255 temporal_type data_type::compute_temporal_type(temporal_type l_tempo, string &op){
 256         temporal_type ret;
 257
 258   if(l_tempo == constant_t) ret = constant_t;
 259   else ret = varying_t;
 260
 261   if(op == "-"){
 262         if(l_tempo == increasing_t) ret = decreasing_t;
 263         else if(l_tempo == decreasing_t) ret = increasing_t;
 264   }
 265   return ret;
 266
 267 }
 268
 269 data_type::data_type(data_type *lhs, data_type *rhs, const string &op){
 270         size=0;
 271
 272   type = undefined_t;
 273   dtype l_type = lhs->get_type();
 274   dtype r_type = rhs->get_type();
 275
 276 //              First, deduce the type of the result.
 277   if( (op=="-")||(op=="+")||(op=="/")||(op=="*")||(op=="%")||(op==">>")||(op=="<<") ){
 278         switch(lhs->get_type()){
 279         case u_short_t:
 280                 switch(rhs->get_type()){
 281                 case u_short_t:
 282                 case u_int_t:
 283                 case int_t:
 284                         type = rhs->get_type();
 285                         break;
 286                 case llong_t:
 287                 case u_llong_t:
 288                         if(op != ">>" && op != "<<")
 289                                 type = rhs->get_type();
 290                         break;
 291                 case floating_t:
 292                         if(op != "%" && op != ">>" && op != "<<")
 293                                 type = floating_t;
 294                         break;
 295                 case timeval_t:
 296                         if(op == "+") type = timeval_t;
 297                         break;
 298                 default:
 299                         break;
 300                 }
 301                 break;
 302         case u_int_t:
 303                 switch(rhs->get_type()){
 304                 case u_short_t:
 305                 case int_t:
 306                 case u_int_t:
 307                         type = u_int_t;
 308                         break;
 309                 case llong_t:
 310                 case u_llong_t:
 311                         if(op != ">>" && op != "<<")
 312                                 type = rhs->get_type();
 313                         break;
 314                 case floating_t:
 315                         if(op != "%" && op != ">>" && op != "<<")
 316                                 type = floating_t;
 317                         break;
 318                 case timeval_t:
 319                         if(op == "+") type = timeval_t;
 320                         break;
 321                 default:
 322                         break;
 323                 }
 324                 break;
 325         case int_t:
 326                 switch(rhs->get_type()){
 327                 case int_t:
 328                 case u_short_t:
 329                         type = int_t;
 330                         break;
 331                 case u_int_t:
 332                         type = rhs->get_type();
 333                         break;
 334                 case llong_t:
 335                 case u_llong_t:
 336                         if(op != ">>" && op != "<<")
 337                                 type = rhs->get_type();
 338                         break;
 339                 case floating_t:
 340                         if(op != "%" && op != ">>" && op != "<<")
 341                                 type = floating_t;
 342                         break;
 343                 case timeval_t:
 344                         if(op == "+") type = timeval_t;
 345                         break;
 346                 default:
 347                         break;
 348                 }
 349                 break;
 350         case llong_t:
 351                 switch(rhs->get_type()){
 352                 case int_t:
 353                 case u_int_t:
 354                 case u_short_t:
 355                         type = llong_t;
 356                         break;
 357                 case llong_t:
 358                         if(op != ">>" && op != "<<")
 359                                 type = llong_t;
 360                         break;
 361                 case u_llong_t:
 362                         if(op != ">>" && op != "<<")
 363                                 type = u_llong_t;
 364                         break;
 365                 case floating_t:
 366                         if(op != "%" && op != ">>" && op != "<<")
 367                                 type = floating_t;
 368                         break;
 369                 default:
 370                         break;
 371                 }
 372                 break;
 373         case u_llong_t:
 374                 switch(rhs->get_type()){
 375                 case int_t:
 376                 case u_int_t:
 377                 case u_short_t:
 378                         type = u_llong_t;
 379                         break;
 380                 case u_llong_t:
 381                 case llong_t:
 382                         if(op != ">>" && op != "<<")
 383                                 type = u_llong_t;
 384                         break;
 385                 case floating_t:
 386                         if(op != "%" && op != ">>" && op != "<<")
 387                                 type = floating_t;
 388                         break;
 389                 default:
 390                         break;
 391                 }
 392                 break;
 393         case floating_t:
 394           if(op != "%" && op != ">>" && op != "<<"){
 395                 switch(rhs->get_type()){
 396                 case int_t:
 397                 case floating_t:
 398                 case u_int_t:
 399                 case u_short_t:
 400                 case llong_t:
 401                 case u_llong_t:
 402                         type = floating_t;
 403                         break;
 404                 default:
 405                         break;
 406                 }
 407           }
 408           break;
 409
 410         case timeval_t:
 411                 switch(rhs->get_type()){
 412                 case int_t:
 413                 case u_int_t:
 414                 case u_short_t:
 415                         if(op == "+" || op == "-" || op == "/"){
 416                                 type = timeval_t;
 417                         }
 418                         break;
 419                 case timeval_t:
 420                         if(op == "-"){
 421                                 type = int_t;
 422                         }
 423                         break;
 424                 default:
 425                         break;
 426                 }
 427         default:
 428                 break;
 429
 430         }
 431   }
 432
 433   if( (op == "|") || (op == "&") ){
 434         switch(lhs->get_type()){
 435         case u_short_t:
 436                 switch(rhs->get_type()){
 437                 case u_short_t:
 438                 case u_int_t:
 439                 case int_t:
 440                 case llong_t:
 441                 case u_llong_t:
 442                         type = rhs->get_type();
 443                         break;
 444                 case bool_t:
 445                         type = bool_t;
 446                         break;
 447                 default:
 448                         break;
 449                 }
 450                 break;
 451         case u_int_t:
 452                 switch(rhs->get_type()){
 453                 case u_short_t:
 454                 case u_int_t:
 455                 case int_t:
 456                         type = u_int_t;
 457                         break;
 458                 case llong_t:
 459                 case u_llong_t:
 460                         type = rhs->get_type();
 461                         break;
 462                 case bool_t:
 463                         type = bool_t;
 464                         break;
 465                         case ip_t:
 466                                 type = ip_t;
 467                                 break;
 468                 default:
 469                         break;
 470                 }
 471                 break;
 472         case int_t:
 473                 switch(rhs->get_type()){
 474                 case int_t:
 475                 case u_short_t:
 476                         type = int_t;
 477                         break;
 478                 case bool_t:
 479                         type = bool_t;
 480                         break;
 481                 case u_int_t:
 482                 case llong_t:
 483                 case u_llong_t:
 484                         type = rhs->get_type();
 485                         break;
 486                         case ip_t:
 487                                 type = ip_t;
 488                                 break;
 489                 default:
 490                         break;
 491                 }
 492                 break;
 493         case llong_t:
 494                 switch(rhs->get_type()){
 495                 case int_t:
 496                 case u_int_t:
 497                 case u_short_t:
 498                 case llong_t:
 499                         type = llong_t;
 500                         break;
 501                 case u_llong_t:
 502                         type = rhs->get_type();
 503                         break;
 504                 case bool_t:
 505                         type = bool_t;
 506                         break;
 507                 default:
 508                         break;
 509                 }
 510                 break;
 511         case u_llong_t:
 512                 switch(rhs->get_type()){
 513                 case int_t:
 514                 case u_int_t:
 515                 case u_short_t:
 516                 case llong_t:
 517                 case u_llong_t:
 518                         type = u_llong_t;
 519                         break;
 520                 case bool_t:
 521                         type = bool_t;
 522                         break;
 523                 default:
 524                         break;
 525                 }
 526                 break;
 527         case bool_t:
 528                 switch(rhs->get_type()){
 529                 case int_t:
 530                 case u_int_t:
 531                 case u_short_t:
 532                 case llong_t:
 533                 case u_llong_t:
 534                 case bool_t:
 535                         type = bool_t;
 536                         break;
 537                 default:
 538                         break;
 539                 }
 540                 break;
 541                 case ip_t:
 542                         switch(rhs->get_type()){
 543                         case int_t:
 544                         case u_int_t:
 545                         case ip_t:
 546                                 type = ip_t;
 547                                 break;
 548                         default:
 549                                 break;
 550                         }
 551                         break;
 552                 case ipv6_t:
 553                         if(rhs->get_type() == ipv6_t)
 554                                 type = ipv6_t;
 555                         break;
 556                 default:
 557                         break;
 558                 }
 559         }
 560         assign_schema_type();
 561         temporal = compute_temporal_type(lhs->get_temporal(),rhs->get_temporal(),lhs->get_type(), rhs->get_type(), op);
 562         if(lhs->subtype == rhs->subtype){
 563                 subtype = lhs->subtype;
 564         }else{
 565                 subtype = "";
 566         }
 567 }
 568
 569
 570 temporal_type data_type::compute_temporal_type(temporal_type l_tempo, temporal_type r_tempo, dtype l_type, dtype r_type, const string &op){
 571         temporal_type ret;
 572
 573 //                      Next, deduce the temporalness of the result.
 574 //                      One complication : if the value of the RHS or LHS is
 575 //                      negative, we can't deduce anything about the temporality
 576 //                      of the result.
 577   ret = varying_t;
 578 //  temporal_type l_tempo = lhs->get_temporal();
 579 //  temporal_type r_tempo = rhs->get_temporal();
 580 //  dtype l_type = lhs->get_type();
 581 //  dtype r_type = rhs->get_type();
 582
 583   if(op == "+"){
 584         if(l_tempo == constant_t) ret = r_tempo;
 585         if(r_tempo == constant_t) ret = l_tempo;
 586         if(l_tempo == r_tempo) ret = r_tempo;
 587   }
 588   if(op == "-"){
 589         if(l_tempo == constant_t && r_tempo == constant_t) ret = constant_t;
 590         if((l_tempo == constant_t || l_tempo ==decreasing_t) &&
 591                      r_tempo == increasing_t &&
 592                         (r_type != int_t && r_type != floating_t) ) ret = decreasing_t;
 593         if((l_tempo == constant_t || l_tempo ==increasing_t) &&
 594                          r_tempo == decreasing_t &&
 595                         (r_type != int_t && r_type != floating_t) ) ret = increasing_t;
 596   }
 597
 598 //              If the value might be negative, can't deduce anything
 599 //                      However Java doesn't have unsigned types so the logic which forbids int has to be relaxed.
 600   if(op == "*"){
 601 //      if((l_type!=int_t && l_type!=floating_t && l_type!=llong_t) && (r_type!=int_t && r_type!=floating_t && r_type!=llong_t)){
 602         if(!((l_type==int_t || l_type==floating_t || l_type==llong_t) && (r_type==int_t || r_type==floating_t || r_type==llong_t))){
 603                 if(l_tempo == constant_t) ret = r_tempo;
 604                 if(r_tempo == constant_t) ret = l_tempo;
 605                 if(l_tempo == r_tempo) ret = r_tempo;
 606          }
 607   }
 608   if(op == "/"){
 609 //      if((l_type!=int_t && l_type!=floating_t && l_type!=llong_t) && (r_type!=int_t && r_type!=floating_t && r_type!=llong_t)){
 610         if(!((l_type==int_t || l_type==floating_t || l_type==llong_t) && (r_type==int_t || r_type==floating_t || r_type==llong_t))){
 611                 if((l_tempo == constant_t || l_tempo ==decreasing_t) &&
 612                                  (r_tempo == increasing_t)) ret = decreasing_t;
 613                 if((l_tempo == constant_t || l_tempo ==increasing_t) &&
 614                                  (r_tempo == decreasing_t )) ret = increasing_t;
 615                 if(r_tempo == constant_t) ret = l_tempo;
 616         }
 617   }
 618
 619   return(ret);
 620
 621 }
 622
 623
 624 data_type *data_type::duplicate(){
 625     data_type *ret = new data_type();
 626     ret->schema_type = schema_type;
 627         ret->size = size;
 628     ret->type = type;
 629     ret->temporal = temporal;
 630         ret->subtype = subtype;
 631
 632     return(ret);
 633 }
 634
 635 field_entry *data_type::make_field_entry(string n){
 636         field_entry *fe = new field_entry(n, schema_type);
 637     if(temporal == increasing_t)
 638         fe->add_modifier("INCREASING");
 639     if(temporal == decreasing_t)
 640         fe->add_modifier("DECREASING");
 641         if(subtype != "") fe->add_modifier("subtype",subtype.c_str());
 642         return fe;
 643 }
 644
 645 bool data_type::fta_legal_operation(
 646                         data_type *lhs, data_type *rhs, string &op){
 647
 648   dtype l_type = lhs->get_type();
 649   dtype r_type = rhs->get_type();
 650
 651
 652 //              Currently, anything goes.  Should be controlled by
 653 //              a config file.
 654
 655         return(true);
 656
 657 //      Only +, -, *, /, |, & are legal in the fta.
 658 //      The only ops on a llong or ullong are +, -
 659 //      no ops on float, timeval permitted, but these
 660 //      are illegal data types in the FTA and are handled elsewhere.
 661
 662   if(!( (op == "-") || (op == "+") || (op == "/") || (op == "*")  || (op == "|") || (op == "&")))
 663         return(false);
 664
 665   if( (l_type == llong_t) || (l_type == u_llong_t) || (r_type == llong_t) || (r_type == u_llong_t)){
 666       if(op == "*" || op == "/")
 667           return(false);
 668   }
 669
 670   return(true);
 671
 672 }
 673
 674
 675 bool data_type::fta_legal_operation(data_type *lhs, string &op){
 676
 677
 678 //      negation and not are as legal at the fta on all fta-legal types
 679 //      as at the user level.
 680     return(true);
 681 }
 682
 683 bool data_type::fta_legal_type(){
 684
 685 //                      Currently, anything goes.
 686 //                      Should control by a config file.
 687 //      Currently, only the float and the timeval are not legal at the fta.
 688 //    if(type == floating_t || type == timeval_t) return(false);
 689
 690     return(true);
 691 }
 692
 693
 694 //              The data type of a literal
 695
 696 data_type::data_type(int it){
 697         temporal = constant_t;
 698         subtype = "";
 699     switch(it){
 700         case LITERAL_INT:
 701                 type = u_int_t;
 702                 break;
 703         case LITERAL_LONGINT:
 704                 type = u_llong_t;
 705                 break;
 706         case LITERAL_FLOAT:
 707                 type = floating_t;
 708                 break;
 709         case LITERAL_STRING:
 710                 type = v_str_t;
 711                 break;
 712         case LITERAL_BOOL:
 713                 type = bool_t;
 714                 break;
 715         case LITERAL_TIMEVAL:
 716                 type = timeval_t;
 717                 break;
 718         case LITERAL_IP:
 719                 type = ip_t;
 720                 break;
 721         case LITERAL_IPV6:
 722                 type = ipv6_t;
 723                 break;
 724         default:
 725                 type = undefined_t;
 726                 break;
 727         }
 728
 729         assign_schema_type();
 730 }
 731
 732 void data_type::set_aggr_data_type(const string &op, data_type *dt){
 733         dtype se_type = dt->type;
 734         type = undefined_t;
 735         temporal = varying_t;
 736
 737     if(op == "AVG"){
 738         if((se_type == u_int_t)||(se_type == u_short_t)||(se_type == int_t)||
 739             (se_type == u_llong_t)||(se_type == llong_t)||(se_type == floating_t))
 740             type = floating_t;
 741     }
 742
 743
 744         if(op == "SUM"){
 745                 if((se_type == u_int_t) || (se_type == u_short_t) || (se_type == bool_t))
 746                         type = u_int_t;
 747                 if((se_type == int_t) || (se_type == u_llong_t) ||
 748                           (se_type == llong_t) || (se_type == floating_t) )
 749                         type = se_type;
 750 //              temporal = dt->temporal;        // temporal not preserved by sum.
 751                 subtype = dt->subtype;
 752         }
 753         if(op == "MIN" || op == "MAX"){
 754                 type = se_type;
 755 //              temporal = dt->temporal;        // temporal not preserved by min or max.
 756                 subtype = dt->subtype;
 757         }
 758         if(op == "AND_AGGR" || op == "OR_AGGR" || op == "XOR_AGGR"){
 759                 if( (se_type == u_int_t) || (se_type == u_short_t) ||
 760                         (se_type == int_t) || (se_type == llong_t) ||
 761                         (se_type == u_llong_t) || (se_type == bool_t) )
 762                                 type = se_type;
 763                 subtype = dt->subtype;
 764         }
 765   assign_schema_type();
 766 }
 767
 768
 769
 770
 771 bool data_type::is_comparable(data_type *rhs, string op){
 772
 773         switch(type){
 774         case u_short_t:
 775         case int_t:
 776         case u_int_t:
 777         case u_llong_t:
 778         case llong_t:
 779         case floating_t:
 780         case ip_t:
 781                 switch(rhs->type){
 782                 case int_t:
 783                 case floating_t:
 784                 case u_short_t:
 785                 case u_int_t:
 786                 case u_llong_t:
 787                 case llong_t:
 788                 case ip_t:
 789                         return(true);
 790                 default:
 791                         return(false);
 792                 }
 793
 794         case v_str_t:
 795                 switch(rhs->type){
 796                 case v_str_t:
 797                         return(true);
 798                 default:
 799                         return(false);
 800                 }
 801
 802         case bool_t:
 803                 switch(rhs->type){
 804                 case bool_t:
 805                         return(true);
 806                 default:
 807                         return(false);
 808                 }
 809         case timeval_t:
 810                 switch(rhs->type){
 811                 case timeval_t:
 812                         return(true);
 813                 default:
 814                         return(false);
 815                 }
 816         case ipv6_t:
 817                 if(rhs->type == ipv6_t)
 818                         return true;
 819                 else
 820                         return false;
 821         default:
 822                 return(false);
 823         }
 824
 825         return(false);
 826 }
 827
 828
 829 //                      type string to get val from pass-by-ref fcn.
 830 //                      (Does not seem to be used ?)
 831 string data_type::get_CC_accessor_type(){
 832         switch(type){
 833         case int_t:
 834                 return("gs_int32_t *");
 835         case bool_t:
 836         case u_short_t:
 837         case u_int_t:
 838         case ip_t:
 839                 return("gs_uint32_t *");
 840         case u_llong_t:
 841                 return("gs_uint64_t *");
 842         case llong_t:
 843                 return("gs_int64_t *");
 844         case floating_t:
 845                 return("gs_float_t *");
 846         case v_str_t:
 847                 return("struct gs_string *");
 848         case fstring_t:
 849                 return("gs_int8_t *");
 850         case timeval_t:
 851                 return("struct timeval *");
 852         case ipv6_t:
 853                 return("struct ipv6_str *");
 854         default:
 855                 return("ERROR: Unknown type in data_type::get_CC_accessor_type\n");
 856         }
 857 }
 858
 859 //              type of a variable holding this value.
 860 string data_type::get_cvar_type(){
 861         char tmps[100];
 862         switch(type){
 863         case int_t:
 864                 return("gs_int32_t ");
 865         case u_int_t:
 866         case u_short_t:
 867         case bool_t:
 868         case ip_t:
 869                 return("gs_uint32_t ");
 870         case u_llong_t:
 871                 return("gs_uint64_t ");
 872         case llong_t:
 873                 return("gs_int64_t ");
 874         case floating_t:
 875                 return("gs_float_t ");
 876         case v_str_t:
 877                 return("struct gs_string");
 878         case ipv6_t:
 879                 return("struct ipv6_str");
 880         case fstring_t:
 881                 sprintf(tmps,"gs_int8_t[%d] ",size);
 882                 return(tmps);
 883         case timeval_t:
 884                 return("struct timeval ");
 885         default:
 886                 return("ERROR: Unknown type in data_type::get_cvar_type\n");
 887         }
 888 }
 889
 890 //              type of a variable holding this value.
 891 string data_type::get_tuple_cvar_type(){
 892         char tmps[100];
 893         switch(type){
 894         case int_t:
 895                 return("gs_int32_t ");
 896         case u_int_t:
 897         case u_short_t:
 898         case bool_t:
 899         case ip_t:
 900                 return("gs_uint32_t ");
 901         case u_llong_t:
 902                 return("gs_uint64_t ");
 903         case llong_t:
 904                 return("gs_int64_t ");
 905         case floating_t:
 906                 return("gs_float_t ");
 907         case v_str_t:
 908                 return("struct string32");
 909         case ipv6_t:
 910                 return("struct ipv6_str");
 911         case fstring_t:
 912                 sprintf(tmps,"gs_int8_t[%d] ",size);
 913                 return(tmps);
 914         case timeval_t:
 915                 return("struct timeval ");
 916         default:
 917                 return("ERROR: Unknown type in data_type::get_cvar_type\n");
 918         }
 919 }
 920
 921
 922
 923 //              type of an in-memory variable holding this value.
 924 //              TODO: use get_cvar_type as a subroutine
 925 string data_type::make_cvar(std::string v){
 926         char tmps[100];
 927         switch(type){
 928         case int_t:
 929                 return("gs_int32_t "+v);
 930         case u_int_t:
 931         case u_short_t:
 932         case bool_t:
 933         case ip_t:
 934                 return("gs_uint32_t "+v);
 935         case u_llong_t:
 936                 return("gs_uint64_t "+v);
 937         case llong_t:
 938                 return("gs_int64_t "+v);
 939         case floating_t:
 940                 return("gs_float_t "+v);
 941         case v_str_t:
 942                 return("struct gs_string "+v);
 943         case ipv6_t:
 944                 return("struct ipv6_str "+v);
 945         case fstring_t:
 946                 sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size);
 947                 return(tmps);
 948         case timeval_t:
 949                 return("struct timeval "+v);
 950         default:
 951                 return("ERROR: Unknown type in data_type::make_cvar\n");
 952         }
 953 }
 954
 955 //              type of a tuple variable holding this value.
 956 //              TODO: use get_tuple_cvar_type as a subroutine
 957 string data_type::make_tuple_cvar(std::string v){
 958         char tmps[100];
 959         switch(type){
 960         case int_t:
 961                 return("gs_int32_t "+v);
 962         case u_int_t:
 963         case u_short_t:
 964         case bool_t:
 965         case ip_t:
 966                 return("gs_uint32_t "+v);
 967         case u_llong_t:
 968                 return("gs_uint64_t "+v);
 969         case llong_t:
 970                 return("gs_int64_t "+v);
 971         case floating_t:
 972                 return("gs_float_t "+v);
 973         case v_str_t:
 974                 return("struct string32 "+v);
 975         case ipv6_t:
 976                 return("struct ipv6_str "+v);
 977         case fstring_t:
 978                 sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size);
 979                 return(tmps);
 980         case timeval_t:
 981                 return("struct timeval "+v);
 982         default:
 983                 return("ERROR: Unknown type in data_type::make_cvar\n");
 984         }
 985 }
 986
 987
 988 //              type of a variable holding this value.
 989 //              The type at the host might be different (esp. string vs. vstring)
 990 string data_type::get_host_cvar_type(){
 991         char tmps[100];
 992         switch(type){
 993         case int_t:
 994                 return("gs_int32_t ");
 995         case u_int_t:
 996         case u_short_t:
 997         case bool_t:
 998         case ip_t:
 999                 return("gs_uint32_t ");
1000         case u_llong_t:
1001                 return("gs_uint64_t ");
1002         case llong_t:
1003                 return("gs_int64_t ");
1004         case floating_t:
1005                 return("gs_float_t ");
1006         case v_str_t:
1007                 return("struct vstring");
1008         case ipv6_t:
1009                 return("struct hfta_ipv6_str");
1010         case fstring_t:
1011                 sprintf(tmps,"gs_int8_t[%d] ",size);
1012                 return(tmps);
1013         case timeval_t:
1014                 return("struct timeval ");
1015         default:
1016                 return("ERROR: Unknown type in data_type::get_host_cvar_type\n");
1017         }
1018 }
1019
1020
1021 //              type of a variable holding this value.
1022 //              The type at the host might be different (esp. string vs. vstring)
1023 string data_type::make_host_cvar(std::string v){
1024         char tmps[100];
1025         switch(type){
1026         case int_t:
1027                 return("gs_int32_t "+v);
1028         case u_int_t:
1029         case u_short_t:
1030         case bool_t:
1031         case ip_t:
1032                 return("gs_uint32_t "+v);
1033         case u_llong_t:
1034                 return("gs_uint64_t "+v);
1035         case llong_t:
1036                 return("gs_int64_t "+v);
1037         case floating_t:
1038                 return("gs_float_t "+v);
1039         case v_str_t:
1040                 return("struct vstring "+v);
1041         case ipv6_t:
1042                 return("struct hfta_ipv6_str "+v);
1043         case fstring_t:
1044                 sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size);
1045                 return(tmps);
1046         case timeval_t:
1047                 return("struct timeval "+v);
1048         default:
1049                 return("ERROR: Unknown type in data_type::make_host_cvar\n");
1050         }
1051 }
1052
1053 string data_type::make_host_tuple_cvar(std::string v){
1054         char tmps[100];
1055         switch(type){
1056         case int_t:
1057                 return("gs_int32_t "+v);
1058         case u_int_t:
1059         case u_short_t:
1060         case bool_t:
1061         case ip_t:
1062                 return("gs_uint32_t "+v);
1063         case u_llong_t:
1064                 return("gs_uint64_t "+v);
1065         case llong_t:
1066                 return("gs_int64_t "+v);
1067         case floating_t:
1068                 return("gs_float_t "+v);
1069         case v_str_t:
1070                 return("struct vstring32 "+v);
1071         case ipv6_t:
1072                 return("struct hfta_ipv6_str "+v);
1073         case fstring_t:
1074                 sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size);
1075                 return(tmps);
1076         case timeval_t:
1077                 return("struct timeval "+v);
1078         default:
1079                 return("ERROR: Unknown type in data_type::make_host_cvar\n");
1080         }
1081 }
1082
1083
1084
1085 string data_type::get_hfta_unpack_fcn(){
1086         switch(type){
1087         case int_t:
1088                 return("fta_unpack_int");
1089         case u_int_t:
1090         case ip_t:
1091                 return("fta_unpack_uint");
1092         case u_short_t:
1093                 return("fta_unpack_ushort");
1094         case bool_t:
1095                 return("fta_unpack_bool");
1096         case u_llong_t:
1097                 return("fta_unpack_ullong");
1098         case llong_t:
1099                 return("fta_unpack_llong");
1100         case floating_t:
1101                 return("fta_unpack_float");
1102         case v_str_t:
1103                 return("fta_unpack_vstr");
1104         case fstring_t:
1105                 return("fta_unpack_fstring");
1106         case timeval_t:
1107                 return("fta_unpack_timeval");
1108         case ipv6_t:
1109                 return("fta_unpack_ipv6");
1110         default:
1111                 return("ERROR: Unknown type in dtype::get_hfta_unpack_fcn\n");
1112         }
1113 }
1114
1115 string data_type::get_hfta_unpack_fcn_noxf(){
1116         switch(type){
1117         case int_t:
1118                 return("fta_unpack_int_noxf");
1119         case u_int_t:
1120         case ip_t:
1121                 return("fta_unpack_uint_noxf");
1122         case u_short_t:
1123                 return("fta_unpack_ushort_noxf");
1124         case bool_t:
1125                 return("fta_unpack_bool_noxf");
1126         case u_llong_t:
1127                 return("fta_unpack_ullong_noxf");
1128         case llong_t:
1129                 return("fta_unpack_llong_noxf");
1130         case floating_t:
1131                 return("fta_unpack_float_noxf");
1132         case v_str_t:
1133                 return("fta_unpack_vstr_noxf");
1134         case fstring_t:
1135                 return("fta_unpack_fstring_noxf");
1136         case timeval_t:
1137                 return("fta_unpack_timeval_noxf");
1138         case ipv6_t:
1139                 return("fta_unpack_ipv6_noxf");
1140         default:
1141                 return("ERROR: Unknown type in dtype::get_hfta_unpack_fcn_noxf\n");
1142         }
1143 }
1144
1145
1146 //              Return true if comparing these types requires
1147 //              a special function.
1148 //              Note:
1149 //                1) the function should act like strcmp (-1, 0, 1)
1150 //                2) this fcn assumes that type checking
1151 //                        has already been done.
1152 bool data_type::complex_comparison(data_type *dt){
1153   switch(type){
1154         case timeval_t:
1155         case ipv6_t:
1156         case v_str_t:
1157         case fstring_t:
1158                 return(true);
1159         default:
1160                 return(false);
1161         }
1162 }
1163
1164 string data_type::get_comparison_fcn(data_type *dt){
1165   switch(type){
1166         case timeval_t:
1167                 return("Compare_Timeval");
1168         case v_str_t:
1169                 return("str_compare");
1170         case ipv6_t:
1171                 return("ipv6_compare");
1172         default:
1173                 return("ERROR_NO_SUCH_COMPARISON_FCN");
1174         }
1175 }
1176 string data_type::get_equals_fcn(data_type *dt){
1177   switch(type){
1178         case timeval_t:
1179                 return("Compare_Timeval");
1180         case v_str_t:
1181                 return("str_equal");
1182         case ipv6_t:
1183                 return("ipv6_compare");
1184         default:
1185                 return("ERROR_NO_SUCH_COMPARISON_FCN");
1186         }
1187 }
1188
1189 string data_type::get_hfta_comparison_fcn(data_type *dt){
1190   switch(type){
1191         case timeval_t:
1192                 return("hfta_Compare_Timeval");
1193         case v_str_t:
1194                 return("hfta_vstr_compare");
1195         case ipv6_t:
1196                 return("hfta_ipv6_compare");
1197         default:
1198                 return("ERROR_NO_SUCH_COMPARISON_FCN");
1199         }
1200 }
1201 string data_type::get_hfta_equals_fcn(data_type *dt){
1202   switch(type){
1203         case timeval_t:
1204                 return("hfta_Compare_Timeval");
1205         case v_str_t:
1206                 return("hfta_vstr_equal");
1207         case ipv6_t:
1208                 return("hfta_ipv6_compare");
1209         default:
1210                 return("ERROR_NO_SUCH_COMPARISON_FCN");
1211         }
1212 }
1213
1214 //              Return true if operating on  these types requires
1215 //              a special function for this operator.
1216 //              Note:
1217 //                1) the function should act like
1218 //                              int operator_fcn(*retun_val, *lhs, *rhs)
1219 //                2) this fcn assumes that type checking
1220 //                        has already been done.
1221 bool data_type::complex_operator(data_type *dt, string &op){
1222         switch(type){
1223         case int_t:
1224                 switch(dt->type){
1225                 case timeval_t:
1226                         if(op == "+")
1227                                 return(true);
1228                         break;
1229                 default:
1230                         break;
1231                 }
1232                 break;
1233         case timeval_t:
1234                 switch(dt->type){
1235                 case int_t:
1236                 case u_int_t:
1237                 case u_short_t:
1238                         if(op == "+" || op == "-" || op == "/")
1239                                 return(true);
1240                         break;
1241                 case timeval_t:
1242                         if(op == "-")
1243                                 return(true);
1244                         break;
1245                 default:
1246                         break;
1247                 }
1248         case ipv6_t:
1249                 if((op=="&" || op=="|") && dt->type == ipv6_t)
1250                         return true;
1251         break;
1252         default:
1253                 break;
1254         }
1255
1256         return(false);
1257 }
1258
1259 bool data_type::complex_operator(string &op){
1260         return(false);
1261 }
1262
1263 string data_type::get_complex_operator(data_type *dt, string &op){
1264         switch(type){
1265         case int_t:
1266                 switch(dt->type){
1267                 case timeval_t:
1268                         if(op == "+")
1269                                 return("Add_Int_Timeval");
1270                         break;
1271                 default:
1272                         break;
1273                 }
1274                 break;
1275         case timeval_t:
1276                 switch(dt->type){
1277                 case int_t:
1278                 case u_int_t:
1279                 case u_short_t:
1280                         if(op == "+")
1281                                 return("Add_Timeval_Int");
1282                         if(op == "-")
1283                                 return("Subtract_Timeval_Int");
1284                         if(op == "/")
1285                                 return("Divide_Timeval_Int");
1286                         break;
1287                 case timeval_t:
1288                         if(op == "-")
1289                                 return("Subtract_Timeval_Timeval");
1290                         break;
1291                 default:
1292                         break;
1293                 }
1294                 break;
1295         case ipv6_t:
1296                 if(dt->type == ipv6_t){
1297                         if(op == "&")
1298                                 return("And_Ipv6");
1299                         if(op == "|")
1300                                 return("Or_Ipv6");
1301                 }
1302                 break;
1303         default:
1304                 break;
1305         }
1306
1307         return("ERROR_NO_COMPLEX_BINARY_OPERATOR");
1308 }
1309
1310 string data_type::get_complex_operator(string &op){
1311
1312         return("ERROR_NO_COMPLEX_UNARY_OPERATOR");
1313 }
1314
1315
1316 bool data_type::use_hashfunc(){
1317         switch(type){
1318         case int_t:
1319         case u_int_t:
1320         case u_short_t:
1321         case bool_t:
1322         case ip_t:
1323                 return(false);
1324         case u_llong_t:
1325         case llong_t:
1326         case floating_t:
1327         case timeval_t:
1328         case ipv6_t:
1329         case v_str_t:
1330                 return(true);
1331         default:
1332                 fprintf(stderr,"ERROR: Unknown type in data_type::use_hashfunc\n");
1333                 exit(1);
1334                 return(false);
1335         }
1336 }
1337 string data_type::get_hfta_hashfunc(){
1338         switch(type){
1339         case int_t:
1340         case u_int_t:
1341         case u_short_t:
1342         case bool_t:
1343         case ip_t:
1344                 return("ERROR NO HFTA HASHFUNC");
1345
1346         case u_llong_t:
1347                 //return("hfta_ullong_hashfunc");
1348                 return("hfta_ULLONG_to_hash");
1349         case llong_t:
1350                 //return("hfta_ullong_hashfunc");
1351                 return("hfta_LLONG_to_hash");
1352         case floating_t:
1353                 //return("hfta_float_hashfunc");
1354                 return("hfta_FLOAT_to_hash");
1355
1356         case ipv6_t:
1357                 return("hfta_IPV6_to_hash");
1358         case timeval_t:
1359                 return("hfta_timeval_hashfunc");
1360         case v_str_t:
1361                 return("hfta_vstr_hashfunc");
1362         default:
1363                 fprintf(stderr,"ERROR: Unknown type in data_type::get_hfta_hashfunc\n");
1364                 exit(1);
1365                 return("false"); // to make compiler happy
1366         }
1367 }
1368
1369 //              Return true if the data type contains a ptr to a
1370 //              memory buffer.  (copying sometimes requires special cate).
1371 //              ASSUMPTION:
1372 bool data_type::is_buffer_type(){
1373         switch(type){
1374         case int_t:
1375         case u_int_t:
1376         case u_short_t:
1377         case bool_t:
1378         case u_llong_t:
1379         case llong_t:
1380         case floating_t:
1381         case timeval_t:
1382         case ipv6_t:
1383         case ip_t:
1384         case fstring_t:
1385                 return(false);
1386         case v_str_t:
1387                 return(true);
1388         default:
1389                 fprintf(stderr,"ERROR: Unknown type in dtype::is_buffer_type\n");
1390                 exit(1);
1391                 return(false);
1392         }
1393 }
1394
1395 //              Fcns which return the names of functions for
1396 //              handling complex types.
1397
1398 //-----------------------------
1399 //              LFTA functions
1400
1401 string data_type::get_buffer_assign_copy(){
1402   switch(type){
1403         case v_str_t:
1404                 return("str_assign_with_copy");
1405         default:
1406                 break;
1407         }
1408
1409         return("ERROR_NO_SUCH_buffer_assign_copy_FCN");
1410 }
1411
1412 string data_type::get_buffer_tuple_copy(){
1413   switch(type){
1414         case v_str_t:
1415                 return("str_assign_with_copy_in_tuple");
1416         default:
1417                 break;
1418         }
1419
1420         return("ERROR_NO_SUCH_buffer_tuple_copy_FCN");
1421 }
1422
1423 string data_type::get_buffer_replace(){
1424   switch(type){
1425         case v_str_t:
1426                 return("str_replace");
1427         default:
1428                 break;
1429         }
1430
1431         return("ERROR_NO_SUCH_buffer_replace_FCN");
1432 }
1433
1434 string data_type::get_buffer_size(){
1435   switch(type){
1436         case v_str_t:
1437                 return("str_length");
1438         default:
1439                 break;
1440         }
1441
1442         return("ERROR_NO_SUCH_buffer_size_FCN");
1443 }
1444
1445 string data_type::get_buffer_destroy(){
1446   switch(type){
1447         case v_str_t:
1448                 return("str_destroy");
1449         default:
1450                 break;
1451         }
1452
1453         return("ERROR_NO_SUCH_buffer_destroy_FCN");
1454 }
1455
1456 //-----------------------------
1457 //              HFTA fcns
1458
1459 string data_type::get_hfta_buffer_assign_copy(){
1460   switch(type){
1461         case v_str_t:
1462                 return("hfta_vstr_assign_with_copy");
1463         default:
1464                 break;
1465         }
1466
1467         return("ERROR_NO_SUCH_buffer_assign_copy_FCN");
1468 }
1469
1470 string data_type::get_hfta_buffer_tuple_copy(){
1471   switch(type){
1472         case v_str_t:
1473                 return("hfta_vstr_assign_with_copy_in_tuple");
1474         default:
1475                 break;
1476         }
1477
1478         return("ERROR_NO_SUCH_buffer_tuple_copy_FCN");
1479 }
1480
1481 string data_type::get_hfta_buffer_replace(){
1482   switch(type){
1483         case v_str_t:
1484                 return("hfta_vstr_replace");
1485         default:
1486                 break;
1487         }
1488
1489         return("ERROR_NO_SUCH_buffer_replace_FCN");
1490 }
1491
1492 string data_type::get_hfta_buffer_size(){
1493   switch(type){
1494         case v_str_t:
1495                 return("hfta_vstr_length");
1496         default:
1497                 break;
1498         }
1499
1500         return("ERROR_NO_SUCH_buffer_size_FCN");
1501 }
1502
1503 string data_type::get_hfta_buffer_destroy(){
1504   switch(type){
1505         case v_str_t:
1506                 return("hfta_vstr_destroy");
1507         default:
1508                 break;
1509         }
1510
1511         return("ERROR_NO_SUCH_buffer_destroy_FCN");
1512 }
1513
1514 string data_type::get_hfta_buffer_init(){
1515   switch(type){
1516         case v_str_t:
1517                 return("hfta_vstr_init");
1518         default:
1519                 break;
1520         }
1521
1522         return("ERROR_NO_SUCH_buffer_init_FCN");
1523 }
1524 //-----------------------------
1525
1526
1527 //              Return true if the data type is represented by a strucutre.
1528 bool data_type::is_structured_type(){
1529         switch(type){
1530         case int_t:
1531         case u_int_t:
1532         case u_short_t:
1533         case bool_t:
1534         case u_llong_t:
1535         case llong_t:
1536         case floating_t:
1537         case ip_t:
1538                 return(false);
1539         case timeval_t:
1540         case ipv6_t:
1541         case v_str_t:
1542         case fstring_t:
1543                 return(true);
1544         default:
1545                 fprintf(stderr,"ERROR: Unknown type in dtype::is_structured_type\n");
1546                 exit(1);
1547                 return(false);
1548         }
1549 }
1550
1551
1552 //              type of a variable holding this value.
1553 //                      Seems to be a relic
1554 /*
1555 string data_type::get_interface_type(){
1556         char tmps[100];
1557         switch(type){
1558         case int_t:
1559                 return("int ");
1560         case u_int_t:
1561                 return("unsigned int ");
1562         case u_short_t:
1563                 return("unsigned short int ");
1564         case bool_t:
1565                 return("int ");
1566         case u_llong_t:
1567                 return("unsigned long long int ");
1568         case llong_t:
1569                 return("long long int ");
1570         case floating_t:
1571                 return("double ");
1572         case v_str_t:
1573                 return("ERROR");
1574         case fstring_t:
1575                 sprintf(tmps,"char[%d] ",size);
1576                 return(tmps);
1577         case timeval_t:
1578                 return("ERROR ");
1579         case ipv6_t:
1580                 return "ERROR";
1581         default:
1582                 return("ERROR: Unknown type in dtype::get_interface_type\n");
1583         }
1584 }
1585 */
1586
1587
1588 //              This type of handle registration is obsolete
1589
1590 string data_type::handle_registration_name(){
1591
1592                 switch(type){
1593                 case v_str_t:
1594                         return("str_register_search_string");
1595                 default:
1596                         return("");
1597                 }
1598                 return("ERROR UNKNOWN LITERAL");
1599         };
1600
1601 string data_type::hfta_handle_registration_name(){
1602
1603                 switch(type){
1604                 case v_str_t:
1605                         return("vstr_register_search_string");
1606                 default:
1607                         return("");
1608                 }
1609                 return("ERROR UNKNOWN LITERAL");
1610         };
1611
1612
1613 string data_type::get_handle_destructor(){
1614
1615                 switch(type){
1616                 case v_str_t:
1617                         return("str_release_search_string");
1618                 default:
1619                         return("");
1620                 }
1621                 return("ERROR UNKNOWN LITERAL");
1622         };
1623
1624
1625 //  should be the inverse of
1626 //      data_type::data_type(string st, param_list *modifiers)
1627 vector<string> data_type::get_param_keys(){
1628     vector<string> retval;
1629
1630     if(temporal == increasing_t)
1631         retval.push_back("INCREASING");
1632     if(temporal == decreasing_t)
1633         retval.push_back("DECREASING");
1634         if(subtype != "") retval.push_back("subtype");
1635
1636     return(retval);
1637 }
1638
1639 string data_type::get_param_val(string k){
1640         if(k=="subtype") return subtype;
1641         return "";
1642 }
1643
1644 std::string data_type::get_temporal_string(){
1645     if(temporal == increasing_t)
1646         return("INCREASING");
1647     if(temporal == decreasing_t)
1648         return("DECREASING");
1649         return("");
1650 }
1651
1652
1653 bool data_type::needs_hn_translation(){
1654         switch(type){
1655         case int_t:
1656         case u_int_t:
1657         case u_short_t:
1658         case bool_t:
1659         case u_llong_t:
1660         case llong_t:
1661         case floating_t:
1662         case timeval_t:
1663         case ipv6_t:
1664         case v_str_t:
1665         case ip_t:
1666                 return(true);
1667         case fstring_t:
1668                 return(false);
1669         default:
1670                 fprintf(stderr,"INTERNAL ERROR: Unknown type in dtype::needs_hn_translation\n");
1671                 exit(1);
1672                 return(false);
1673         }
1674 }
1675
1676 std::string data_type::hton_translation(){
1677 fprintf(stderr,"INTERNAL ERROR, hton_translation called.\n");
1678 return("");
1679
1680         switch(type){
1681         case int_t:
1682         case u_int_t:
1683         case u_short_t:
1684         case bool_t:
1685         case ip_t:
1686                 return("htonl");
1687                 break;
1688         case u_llong_t:
1689         case llong_t:
1690                 return("htonll");
1691                 break;
1692         case floating_t:
1693                 return("htonf");
1694                 break;
1695         case timeval_t:
1696                 return("htontv");
1697                 break;
1698         case ipv6_t:
1699                 return("hton_ipv6");
1700                 break;
1701         case v_str_t:
1702                 return("INTERNAL ERROR, net translation for buffered types needs special handling.\n");
1703         default:
1704                 fprintf(stderr,"INTERNAL ERROR: Unknown type in dtype::hton_translation\n");
1705                 exit(1);
1706                 return("INTERNAL ERROR: NO SUCH TYPE IN hton_translation");
1707         }
1708 }
1709
1710 std::string data_type::ntoh_translation(){
1711 fprintf(stderr,"INTERNAL ERROR, ntoh_translation called.\n");
1712 return("");
1713
1714         switch(type){
1715         case int_t:
1716         case u_int_t:
1717         case u_short_t:
1718         case bool_t:
1719         case ip_t:
1720                 return("ntohl");
1721                 break;
1722         case u_llong_t:
1723         case llong_t:
1724                 return("ntohll");
1725                 break;
1726         case floating_t:
1727                 return("ntohf");
1728                 break;
1729         case timeval_t:
1730                 return("ntohtv");
1731                 break;
1732         case ipv6_t:
1733                 return("ntoh_ipv6");
1734                 break;
1735         case v_str_t:
1736                 return("INTERNAL ERROR, net translation for buffered types needs special handling.\n");
1737         default:
1738                 fprintf(stderr,"INTERNAL ERROR: Unknown type in dtype::ntoh_translation\n");
1739                 exit(1);
1740                 return("INTERNAL ERROR: NO SUCH TYPE IN ntoh_translation");
1741         }
1742 }
1743
1744 int data_type::type_indicator(){
1745         switch(type){
1746         case int_t:
1747                 return(INT_TYPE);
1748         case u_int_t:
1749                 return(UINT_TYPE);
1750         case u_short_t:
1751                 return(USHORT_TYPE);
1752         case bool_t:
1753                 return(BOOL_TYPE);
1754         case u_llong_t:
1755                 return(ULLONG_TYPE);
1756         case llong_t:
1757                 return(LLONG_TYPE);
1758         case floating_t:
1759                 return(FLOAT_TYPE);
1760         case timeval_t:
1761                 return(TIMEVAL_TYPE);
1762         case ipv6_t:
1763                 return(IPV6_TYPE);
1764         case ip_t:
1765                 return(IP_TYPE);
1766         case v_str_t:
1767                 return(VSTR_TYPE);
1768         case fstring_t:
1769                 return(FSTRING_TYPE);
1770         default:
1771                 return(UNDEFINED_TYPE);
1772         }
1773         return(UNDEFINED_TYPE);
1774 }
1775
1776 //              for schemaparser
1777
1778 int data_type::type_size(){
1779         switch(type){
1780         case int_t:
1781                 return(sizeof(gs_int32_t));
1782         case u_int_t:
1783         case u_short_t:
1784         case bool_t:
1785         case ip_t:
1786                 return(sizeof(gs_uint32_t));
1787         case u_llong_t:
1788                 return(sizeof(gs_uint64_t));
1789         case llong_t:
1790                 return(sizeof(gs_int64_t));
1791         case floating_t:
1792                 return(sizeof(gs_float_t));
1793         case timeval_t:
1794                 return(sizeof(timeval));                // IMPLEMENTATION DEPENDENT
1795         case ipv6_t:
1796                 return(sizeof(hfta_ipv6_str));          // IMPLEMENTATION DEPENDENT
1797         case v_str_t:
1798                 return(sizeof(vstring32));              // IMPLEMENTATION DEPENDENT
1799         case fstring_t:
1800                 return(size);
1801         default:
1802                 return(0);
1803         }
1804         return(0);
1805 }
1806
1807 //              for external functions and predicates
1808
1809 /*
1810 bool data_type::call_compatible(data_type *o){
1811         if(type != o->get_type()) return(false);
1812         if(type == fstring_t){
1813                 if(size != 0 && size != o->type_size()) return(false);
1814         }
1815         return(true);
1816 }
1817
1818 //              test for equality : used by bind_to_schema and by testing for
1819 //              mergability.
1820
1821 bool data_type::equal(data_type *o){
1822         if(type != o->get_type()) return(false);
1823         if(type == fstring_t){
1824                 if(size != o->type_size()) return(false);
1825         }
1826         return(true);
1827 }
1828 */
1829
1830 bool data_type::subsumes_type(data_type *o){
1831         if(type != o->get_type()) return(false);
1832         if(type == fstring_t){
1833                 if(size != o->type_size()) return(false);
1834         }
1835         if(this->is_temporal() && temporal != o->get_temporal()) return false;
1836         if(subtype != "" && subtype != o->subtype) return false;
1837
1838         return(true);
1839 }
1840
1841 bool data_type::equals(data_type *o){
1842         if(type != o->get_type()) return(false);
1843         if(type == fstring_t){
1844                 if(size != o->type_size()) return(false);
1845         }
1846         if(temporal != o->get_temporal()) return false;
1847         if(subtype != o->subtype) return false;
1848
1849         return(true);
1850 }
1851
1852 bool data_type::equal_subtypes(data_type *o){
1853         if(type != o->get_type()) return(false);
1854         if(type == fstring_t){
1855                 if(size != o->type_size()) return(false);
1856         }
1857         if(subtype != o->subtype) return false;
1858
1859         return(true);
1860 }
1861
1862
1863 string data_type::to_string(){
1864         string ret = schema_type;
1865         if(this->is_temporal() || subtype != ""){
1866                 ret += " (";
1867                  if(temporal == increasing_t)
1868                 ret += "INCREASING";
1869         if(temporal == decreasing_t)
1870                 ret += "DECREASING";
1871                 if(this->is_temporal() && subtype != "")
1872                         ret += ", ";
1873                 if(subtype != "")
1874                         ret += "subtype "+subtype;
1875                 ret += ")";
1876         }
1877         return ret;
1878 }
1879
1880
1881
1882 string data_type::get_min_literal() {
1883         switch(type){
1884         case int_t:
1885                 return("INT_MIN");
1886         case bool_t:
1887         case u_short_t:
1888         case u_int_t:
1889         case ip_t:
1890                 return("0");
1891         case u_llong_t:
1892                 return("0");
1893         case llong_t:
1894                 return("LLONG_MIN");
1895         case floating_t:
1896                 return("DBL_MIN");
1897         case timeval_t:
1898                 return("{0,0}");
1899         case ipv6_t:
1900                 return("0000:0000:0000:0000:0000:0000:0000:0000");
1901         case v_str_t:
1902         case fstring_t:
1903                 return("ERROR: Min literal is undefined for strings\n");
1904         default:
1905                 return("ERROR: Unknown type in data_type::get_min_literal\n");
1906         }
1907 }
1908
1909 string data_type::get_max_literal() {
1910         switch(type){
1911         case int_t:
1912                 return("INT_MAX");
1913         case bool_t:
1914         case u_short_t:
1915         case u_int_t:
1916         case ip_t:
1917                 return("UINT_MAX");
1918         case u_llong_t:
1919                 return("ULLONG_MAX");
1920         case llong_t:
1921                 return("LLONG_MAX");
1922         case floating_t:
1923                 return("DBL_MAX");
1924         case timeval_t:
1925                 return("{UINT_MAX,UINT_MAX}");
1926         case ipv6_t:
1927                 return("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
1928         case v_str_t:
1929         case fstring_t:
1930                 return("ERROR: Max literal is undefined for strings\n");
1931         default:
1932                 return("ERROR: Unknown type in data_type::get_max_literal\n");
1933         }
1934
1935 }
1936
1937 string data_type::get_wl_extract_fcn() {
1938         switch(type){
1939         case int_t:
1940                 return("wl_csv_int");
1941         case bool_t:
1942                 return("wl_csv_bool");
1943         case u_short_t:
1944         case u_int_t:
1945                 return("wl_csv_uint");
1946         case ip_t:
1947                 return("wl_csv_ip");
1948         case u_llong_t:
1949                 return("wl_csv_ullong");
1950         case llong_t:
1951                 return("wl_csv_llong");
1952         case floating_t:
1953                 return("wl_csv_float");
1954         case timeval_t:
1955                 return("ERROR_TIMEVAL_T_EXTRACTION_NOT_SUPPORTED");
1956         case ipv6_t:
1957                 return("wl_csv_ipv6");
1958         case v_str_t:
1959         case fstring_t:
1960                 return("wl_csv_string");
1961         default:
1962                 return("ERROR: Unknown type in data_type::get_wl_extract_fcn\n");
1963         }
1964
1965 }
1966
1967