modules/up/src/rpsl/rpsl/rptype.cc

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. Attribute
  2. newRPType
  3. newRPType
  4. newRPType
  5. newRPType
  6. validate
  7. typeCast
  8. validate
  9. validate
  10. validate
  11. typeCast
  12. validate
  13. validate
  14. validate
  15. typeCast
  16. validate
  17. validate
  18. typeCast
  19. validate
  20. validate
  21. validate
  22. validate
  23. validate
  24. validate
  25. validate
  26. validate
  27. typeCast
  28. validate
  29. validate
  30. validate
  31. validate
  32. validate
  33. validate
  34. typeCast
  35. validate
  36. validate
  37. validate
  38. typeCast
  39. validate
  40. typeCast
  41. name
  42. validate
  43. typeCast
  44. validate
  45. validate

   1 //  $Id: rptype.cc,v 1.2 2001/09/07 11:43:11 shane Exp $
   2 //
   3 //  Copyright (c) 1994 by the University of Southern California
   4 //  All rights reserved.
   5 //
   6 //  Permission to use, copy, modify, and distribute this software and its
   7 //  documentation in source and binary forms for lawful non-commercial
   8 //  purposes and without fee is hereby granted, provided that the above
   9 //  copyright notice appear in all copies and that both the copyright
  10 //  notice and this permission notice appear in supporting documentation,
  11 //  and that any documentation, advertising materials, and other materials
  12 //  related to such distribution and use acknowledge that the software was
  13 //  developed by the University of Southern California, Information
  14 //  Sciences Institute. The name of the USC may not be used to endorse or
  15 //  promote products derived from this software without specific prior
  16 //  written permission.
  17 //
  18 //  THE UNIVERSITY OF SOUTHERN CALIFORNIA DOES NOT MAKE ANY
  19 //  REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR ANY
  20 //  PURPOSE.  THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
  21 //  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  22 //  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE,
  23 //  TITLE, AND NON-INFRINGEMENT.
  24 //
  25 //  IN NO EVENT SHALL USC, OR ANY OTHER CONTRIBUTOR BE LIABLE FOR ANY
  26 //  SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, WHETHER IN CONTRACT, TORT,
  27 //  OR OTHER FORM OF ACTION, ARISING OUT OF OR IN CONNECTION WITH, THE USE
  28 //  OR PERFORMANCE OF THIS SOFTWARE.
  29 //
  30 //  Questions concerning this software should be directed to 
  31 //  ratoolset@isi.edu.
  32 //
  33 //  Author(s): Cengiz Alaettinoglu <cengiz@ISI.EDU>
  34 
  35 #include "config.h"
  36 #include <cstring>
  37 #include <cstdarg>
  38 #include <cstdio>
  39 #include <typeinfo>
  40 #include "util/List.hh"
  41 
  42 class Attribute;
     /* [<][>][^][v][top][bottom][index][help] */
  43 #include "rptype.hh"
  44 #include "schema.hh"
  45 
  46 
  47 ////////////////////////////// RPType ////////////////////
  48 
  49 RPType *RPType::newRPType(char *name) {
  50    if (!strcasecmp(name, "integer"))
  51       return new RPTypeInt;
  52    if (!strcasecmp(name, "real"))
  53       return new RPTypeReal;
  54    if (!strcasecmp(name, "rpsl_word"))
  55       return new RPTypeWord;
  56    //   if (!strcasecmp(name, "blob"))
  57    //      return new RPTypeBlob;
  58    if (!strcasecmp(name, "as_number"))
  59       return new RPTypeASNumber;
  60    if (!strcasecmp(name, "ipv4_address"))
  61       return new RPTypeIPv4Address;
  62    if (!strcasecmp(name, "address_prefix"))
  63       return new RPTypeIPv4Prefix;
  64    if (!strcasecmp(name, "ipv6_prefix"))
  65       return new RPTypeIPv6Prefix;
  66    if (!strcasecmp(name, "address_prefix_range"))
  67       return new RPTypeIPv4PrefixRange;
  68    if (!strcasecmp(name, "connection"))
  69       return new RPTypeConnection;
  70    if (!strcasecmp(name, "dns_name"))
  71       return new RPTypeDNSName;
  72    if (!strcasecmp(name, "filter"))
  73       return new RPTypeFilter;
  74    if (!strcasecmp(name, "as_set_name"))
  75       return new RPTypeASName;
  76    if (!strcasecmp(name, "route_set_name"))
  77       return new RPTypeRSName;
  78    if (!strcasecmp(name, "rtr_set_name"))
  79       return new RPTypeRtrsName;
  80    if (!strcasecmp(name, "peering_set_name"))
  81       return new RPTypePrngName;
  82    if (!strcasecmp(name, "filter_set_name"))
  83       return new RPTypeFltrName;
  84    if (!strcasecmp(name, "string"))
  85       return new RPTypeString;
  86    if (!strcasecmp(name, "time_stamp"))
  87       return new RPTypeTimeStamp;
  88    if (!strcasecmp(name, "boolean"))
  89       return new RPTypeBoolean;
  90    if (!strcasecmp(name, "free_text"))
  91       return new RPTypeFreeText;
  92    if (!strcasecmp(name, "email"))
  93       return new RPTypeEMail;
  94 //   if(!strcasecmp(name, "nichdl"))
  95 //      return new RPTypeNICHdl;
  96    if(!strcasecmp(name, "keycrtname"))
  97       return new RPTypeKeyCrtName;
  98 
  99    return schema.searchTypedef(name);
 100 }
 101 
 102 RPType *RPType::newRPType(char *name, long long int min, long long int max) {
     /* [<][>][^][v][top][bottom][index][help] */
 103    if (!strcasecmp(name, "integer"))
 104       return new RPTypeInt(min, max);
 105    if (!strcasecmp(name, "real"))
 106       return new RPTypeReal(min, max);
 107 
 108    return NULL;
 109 }
 110 
 111 RPType *RPType::newRPType(char *name, double min, double max) {
     /* [<][>][^][v][top][bottom][index][help] */
 112    if (!strcasecmp(name, "real"))
 113       return new RPTypeReal(min, max);
 114 
 115    return NULL;
 116 }
 117 
 118 RPType *RPType::newRPType(char *name, List<WordNode> *words) {
     /* [<][>][^][v][top][bottom][index][help] */
 119    if (!strcasecmp(name, "enum"))
 120       return new RPTypeEnum(words);
 121 
 122    return NULL;
 123 }
 124 
 125 RPType *RPType::newRPType(char *name, List<RPTypeNode> *types) {
     /* [<][>][^][v][top][bottom][index][help] */
 126    if (types && !types->isEmpty())
 127       if (!strcasecmp(name, "union"))
 128          return new RPTypeUnion(types);
 129 
 130    return NULL;
 131 }
 132 
 133 bool RPType::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 134    return false;
 135 }
 136 Item *RPType::typeCast(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 137    return NULL;
 138 }
 139 bool RPType::validate(ItemList *list) const {
     /* [<][>][^][v][top][bottom][index][help] */
 140    if (! list->isSingleton())
 141       return false;
 142    if (validate(list->head()))
 143       return true;
 144    
 145    Item *w = typeCast(list->head());
 146    if (!w)
 147       return false;
 148    
 149    list->clear();
 150    list->append(w);
 151 
 152    return true;
 153 }
 154 
 155 ////////////////////////////// RPTypeInt ////////////////////
 156 
 157 bool RPTypeInt::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 158    return (typeid(*item) == typeid(ItemINT) 
 159            && min <= ((ItemINT *) item)->i
 160            && max >= ((ItemINT *) item)->i);
 161 }
 162 
 163 ////////////////////////////// RPTypeReal ////////////////////
 164 
 165 bool RPTypeReal::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 166    return (typeid(*item) == typeid(ItemREAL) 
 167            && min <= ((ItemREAL *) item)->real
 168            && max >= ((ItemREAL *) item)->real);
 169 }
 170 
 171 Item *RPTypeReal::typeCast(const Item  *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 172    if (typeid(*item) == typeid(ItemINT)  
 173        && min <= ((ItemINT *) item)->i
 174        && max >= ((ItemINT *) item)->i)
 175       return new ItemREAL(((ItemINT *) item)->i);
 176 
 177    return NULL;
 178 }
 179 
 180 ////////////////////////////// RPTypeString ////////////////////
 181 
 182 bool RPTypeString::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 183    return (typeid(*item) == typeid(ItemSTRING));
 184 }
 185 
 186 ////////////////////////////// RPTypeTimeStamp ////////////////////
 187 
 188 bool RPTypeTimeStamp::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 189    return (typeid(*item) == typeid(ItemTimeStamp));
 190 }
 191 
 192 ////////////////////////////// RPTypeWORD ////////////////////
 193 
 194 bool RPTypeWord::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 195    return (typeid(*item) == typeid(ItemWORD));
 196 }
 197 Item *RPTypeWord::typeCast(const Item  *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 198    if (typeid(*item) == typeid(ItemASNAME)){
 199       return new ItemWORD(strdup(((ItemASNAME *) item)->name));
 200    }
 201    if (typeid(*item) == typeid(ItemRSNAME))
 202       return new ItemWORD(strdup(((ItemRSNAME *) item)->name));
 203    if (typeid(*item) == typeid(ItemRTRSNAME))
 204       return new ItemWORD(strdup(((ItemRTRSNAME *) item)->name));
 205    if (typeid(*item) == typeid(ItemPRNGNAME))
 206       return new ItemWORD(strdup(((ItemPRNGNAME *) item)->name));
 207 //   if (typeid(*item) == typeid(ItemNICHDL)){
 208 //      cout << "typecasting: ItemNICHDL->ItemWORD" << endl;
 209 //      return new ItemWORD(strdup(((ItemNICHDL *) item)->nichdl));
 210 //   }
 211    if (typeid(*item) == typeid(ItemFLTRNAME))
 212       return new ItemWORD(strdup(((ItemFLTRNAME *) item)->name));
 213    if (typeid(*item) == typeid(ItemKEYCRTNAME))
 214       return new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
 215    if (typeid(*item) == typeid(ItemBOOLEAN))
 216       if (((ItemBOOLEAN *) item)->i)
 217          return new ItemWORD(strdup("true"));
 218       else
 219          return new ItemWORD(strdup("false"));
 220    if (typeid(*item) == typeid(ItemASNO)) {
 221       char buffer[64];
 222       sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
 223       return new ItemWORD(strdup(buffer));
 224    }
 225 
 226    return NULL;
 227 }
 228 
 229 ////////////////////////////// RPTypeNICHdl ////////////////////
 230 /*
 231 bool RPTypeNICHdl::validate(const Item *item) const {
 232    if(typeid(*item) == typeid(ItemNICHDL)){
 233       cout << "Debug: RPTypeNICHdl::validate (nichdl = "<< ((ItemNICHDL *) item)->nichdl << ")" << endl;
 234    }else{
 235       cout << "Debug: RPTypeNICHdl::validate" << endl;
 236    }
 237    cout << "Debug: RPTypeNICHdl::validate " << typeid(*item).name() << " " << typeid(ItemNICHDL).name() << endl;
 238 //   return false;
 239    return (typeid(*item) == typeid(ItemNICHDL)
 240             && ((strchr(((ItemNICHDL *) item)->nichdl,'q') != NULL) 
 241                || (strchr(((ItemNICHDL *) item)->nichdl,'Q') != NULL)));
 242 }
 243 */
 244 /*Item *RPTypeNICHdl::typeCast(const Item  *item) const {
 245    if (typeid(*item) == typeid(ItemWORD)){
 246       cout << "typecasting: ItemWORD -> ItemNICHDL" << endl;
 247       return new ItemNICHDL(strdup(((ItemWORD *) item)->word));
 248    }
 249    if (typeid(*item) == typeid(ItemASNAME))
 250       return new ItemNICHDL(strdup(((ItemASNAME *) item)->name));
 251    if (typeid(*item) == typeid(ItemRSNAME))
 252       return new ItemNICHDL(strdup(((ItemRSNAME *) item)->name));
 253    if (typeid(*item) == typeid(ItemRTRSNAME))
 254       return new ItemNICHDL(strdup(((ItemRTRSNAME *) item)->name));
 255    if (typeid(*item) == typeid(ItemPRNGNAME))
 256       return new ItemNICHDL(strdup(((ItemPRNGNAME *) item)->name));
 257    if (typeid(*item) == typeid(ItemFLTRNAME))
 258       return new ItemNICHDL(strdup(((ItemFLTRNAME *) item)->name));
 259    if (typeid(*item) == typeid(ItemKEYCRTNAME))
 260       return new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
 261    if (typeid(*item) == typeid(ItemBOOLEAN))
 262       if (((ItemBOOLEAN *) item)->i)
 263          return new ItemNICHDL(strdup("true"));
 264       else
 265          return new ItemNICHDL(strdup("false"));
 266    if (typeid(*item) == typeid(ItemASNO)) {
 267       char buffer[64];
 268       sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
 269       return new ItemNICHDL(strdup(buffer));
 270    }
 271 
 272    return NULL;
 273 }*/
 274 
 275 ////////////////////////////// RPTypeKeyCrtName ////////////////////
 276 
 277 bool RPTypeKeyCrtName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 278    return (typeid(*item) == typeid(ItemKEYCRTNAME));
 279 }
 280 //Item *RPTypeKeyCrtName::typeCast(const Item  *item) const {
 281 //   if (typeid(*item) == typeid(ItemWORD))
 282 //      return new ItemKEYCRTNAME(strdup(((ItemWORD *) item)->word));
 283 //   if (typeid(*item) == typeid(ItemASNAME))
 284 //      return new ItemKEYCRTNAME(strdup(((ItemASNAME *) item)->name));
 285 //   if (typeid(*item) == typeid(ItemRSNAME))
 286 //      return new ItemKEYCRTNAME(strdup(((ItemRSNAME *) item)->name));
 287 //   if (typeid(*item) == typeid(ItemRTRSNAME))
 288 //      return new ItemKEYCRTNAME(strdup(((ItemRTRSNAME *) item)->name));
 289 //   if (typeid(*item) == typeid(ItemPRNGNAME))
 290 //      return new ItemKEYCRTNAME(strdup(((ItemPRNGNAME *) item)->name));
 291 //   if (typeid(*item) == typeid(ItemFLTRNAME))
 292 //      return new ItemKEYCRTNAME(strdup(((ItemFLTRNAME *) item)->name));
 293 //   if (typeid(*item) == typeid(ItemNICHDL))
 294 //      return new ItemKEYCRTNAME(strdup(((ItemNICHDL *) item)->nichdl));
 295 //   if (typeid(*item) == typeid(ItemBOOLEAN))
 296 //      if (((ItemBOOLEAN *) item)->i)
 297 //       return new ItemNICHDL(strdup("true"));
 298 //      else
 299 //       return new ItemNICHDL(strdup("false"));
 300 //   if (typeid(*item) == typeid(ItemASNO)) {
 301 //      char buffer[64];
 302 //      sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
 303 //      return new ItemNICHDL(strdup(buffer));
 304 //   }
 305 //
 306 //   return NULL;
 307 //}
 308 
 309 ////////////////////////////// RPTypeBlob ////////////////////
 310 
 311 bool RPTypeBlob::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 312    return (typeid(*item) == typeid(ItemBLOB));
 313 }
 314 
 315 Item *RPTypeBlob::typeCast(const Item  *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 316    if (typeid(*item) == typeid(ItemASNAME))
 317       return new ItemBLOB(strdup(((ItemASNAME *) item)->name));
 318    if (typeid(*item) == typeid(ItemRSNAME))
 319       return new ItemBLOB(strdup(((ItemRSNAME *) item)->name));
 320    if (typeid(*item) == typeid(ItemRTRSNAME))
 321       return new ItemBLOB(strdup(((ItemRTRSNAME *) item)->name));
 322    if (typeid(*item) == typeid(ItemPRNGNAME))
 323       return new ItemBLOB(strdup(((ItemPRNGNAME *) item)->name));
 324    if (typeid(*item) == typeid(ItemFLTRNAME))
 325       return new ItemBLOB(strdup(((ItemFLTRNAME *) item)->name));
 326   // if (typeid(*item) == typeid(ItemNICHDL))
 327   //    return new ItemBLOB(strdup(((ItemNICHDL *) item)->nichdl));
 328    if (typeid(*item) == typeid(ItemKEYCRTNAME))
 329       return new ItemBLOB(strdup(((ItemKEYCRTNAME *) item)->name));
 330    if (typeid(*item) == typeid(ItemBOOLEAN))
 331       if (((ItemBOOLEAN *) item)->i)
 332          return new ItemBLOB(strdup("true"));
 333       else
 334          return new ItemBLOB(strdup("false"));
 335    if (typeid(*item) == typeid(ItemASNO)) {
 336       char buffer[64];
 337       sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
 338       return new ItemWORD(strdup(buffer));
 339    }
 340 
 341    return NULL;
 342 }
 343 
 344 ////////////////////////////// RPTypeASName ////////////////////
 345 
 346 bool RPTypeASName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 347    return (typeid(*item) == typeid(ItemASNAME));
 348 }
 349 
 350 ////////////////////////////// RPTypeRSName ////////////////////
 351 
 352 bool RPTypeRSName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 353    return (typeid(*item) == typeid(ItemRSNAME));
 354 }
 355 
 356 ////////////////////////////// RPTypeRTRSName ////////////////////
 357 
 358 bool RPTypeRtrsName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 359    return (typeid(*item) == typeid(ItemRTRSNAME));
 360 }
 361 
 362 ////////////////////////////// RPTypePrngName ////////////////////
 363 
 364 bool RPTypePrngName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 365    return (typeid(*item) == typeid(ItemPRNGNAME));
 366 }
 367 
 368 ////////////////////////////// RPTypeFltrName ////////////////////
 369 
 370 bool RPTypeFltrName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 371    return (typeid(*item) == typeid(ItemFLTRNAME));
 372 }
 373 
 374 ////////////////////////////// RPTypeEMail ////////////////////
 375 
 376 bool RPTypeEMail::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 377    return (typeid(*item) == typeid(ItemEMAIL));
 378 }
 379 
 380 ////////////////////////////// RPTypeFreeText ////////////////////
 381 
 382 bool RPTypeFreeText::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 383    return (typeid(*item) == typeid(ItemFREETEXT));
 384 }
 385 
 386 ////////////////////////////// RPTypeEnum ////////////////////
 387 
 388 bool RPTypeEnum::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 389    if (typeid(*item) != typeid(ItemWORD))
 390          return false;
 391    
 392    for (WordNode* p = words->head(); p; p = words->next(p))
 393          if (!strcasecmp(((ItemWORD *) item)->word, p->word))
 394             return true;
 395 
 396    return false;
 397 }
 398 
 399 Item *RPTypeEnum::typeCast(const Item  *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 400    ItemWORD *w = NULL;
 401 
 402    if (typeid(*item) == typeid(ItemASNAME))
 403       w = new ItemWORD(strdup(((ItemASNAME *) item)->name));
 404    if (typeid(*item) == typeid(ItemRSNAME))
 405       w = new ItemWORD(strdup(((ItemRSNAME *) item)->name));
 406    if (typeid(*item) == typeid(ItemRTRSNAME))
 407       w = new ItemWORD(strdup(((ItemRTRSNAME *) item)->name));
 408    if (typeid(*item) == typeid(ItemPRNGNAME))
 409       w = new ItemWORD(strdup(((ItemPRNGNAME *) item)->name));
 410    if (typeid(*item) == typeid(ItemFLTRNAME))
 411       w = new ItemWORD(strdup(((ItemFLTRNAME *) item)->name));
 412 //   if (typeid(*item) == typeid(ItemNICHDL))
 413 //      w = new ItemWORD(strdup(((ItemNICHDL *) item)->nichdl));
 414    if (typeid(*item) == typeid(ItemKEYCRTNAME))
 415       w = new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
 416    if (typeid(*item) == typeid(ItemBOOLEAN))
 417       if (((ItemBOOLEAN *) item)->i)
 418          w = new ItemWORD(strdup("true"));
 419       else
 420          w = new ItemWORD(strdup("false"));
 421    if (typeid(*item) == typeid(ItemASNO)) {
 422       char buffer[64];
 423       sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
 424       w = new ItemWORD(strdup(buffer));
 425    }
 426 
 427    if (w && validate(w))
 428       return w;
 429    if (w)
 430       delete w;
 431 
 432    return NULL;
 433 }
 434 
 435 ////////////////////////////// RPTypeBoolean ////////////////////
 436 
 437 bool RPTypeBoolean::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 438    return (typeid(*item) == typeid(ItemBOOLEAN));
 439 }
 440 
 441 ////////////////////////////// RPTypeASNumber ////////////////////
 442 
 443 bool RPTypeASNumber::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 444    return ((typeid(*item) == typeid(ItemASNO))
 445            && ((ItemASNO *) item)->asno <= 65535);
 446 }
 447 
 448 ////////////////////////////// RPTypeIPv4Address ////////////////////
 449 
 450 bool RPTypeIPv4Address::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 451    return (typeid(*item) == typeid(ItemIPV4));
 452 }
 453 
 454 ////////////////////////////// RPTypeIPv4Prefix ////////////////////
 455 
 456 bool RPTypeIPv4Prefix::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 457    return (typeid(*item) == typeid(ItemPRFXV4));
 458 }
 459 
 460 ////////////////////////////// RPTypeIPv6Prefix ////////////////////
 461 
 462 bool RPTypeIPv6Prefix::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 463       return (typeid(*item) == typeid(ItemPRFXV6));
 464 }
 465 
 466 ////////////////////////////// RPTypeIPv4PrefixRange ////////////////////
 467 
 468 bool RPTypeIPv4PrefixRange::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 469    return (typeid(*item) == typeid(ItemPRFXV4Range));
 470 }
 471 
 472 Item *RPTypeIPv4PrefixRange::typeCast(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 473    if (typeid(*item) == typeid(ItemPRFXV4))
 474       return new ItemPRFXV4Range
 475          (new PrefixRange(*((ItemPRFXV4 *) item)->prfxv4));
 476    return NULL;
 477 }
 478 
 479 ////////////////////////////// RPTypeConnection ////////////////////
 480 
 481 bool RPTypeConnection::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 482    return (typeid(*item) == typeid(ItemConnection));
 483 }
 484 
 485 ////////////////////////////// RPTypeDNSName ////////////////////
 486 
 487 bool RPTypeDNSName::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 488    return (typeid(*item) == typeid(ItemDNS));
 489 }
 490 
 491 ////////////////////////////// RPTypeFilter ////////////////////
 492 
 493 bool RPTypeFilter::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 494    return (typeid(*item) == typeid(ItemFilter));
 495 }
 496 
 497 Item *RPTypeFilter::typeCast(const Item  *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 498    if (typeid(*item) == typeid(ItemASNAME))
 499       return new ItemFilter(new FilterASNAME(((ItemASNAME *) item)->name));
 500    if (typeid(*item) == typeid(ItemRSNAME))
 501       return new ItemFilter(new FilterRSNAME(((ItemRSNAME *) item)->name));
 502    if (typeid(*item) == typeid(ItemRTRSNAME))
 503       return new ItemFilter(new FilterRTRSNAME(((ItemRTRSNAME *) item)->name));
 504    if (typeid(*item) == typeid(ItemFLTRNAME))
 505       return new ItemFilter(new FilterFLTRNAME(((ItemFLTRNAME *) item)->name));
 506    if (typeid(*item) == typeid(ItemASNO))
 507       return new ItemFilter(new FilterASNO(((ItemASNO *) item)->asno));
 508 
 509    return NULL;
 510 }
 511 
 512 ////////////////////////////// RPTypeUnion ////////////////////
 513 
 514 bool RPTypeUnion::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 515    for (RPTypeNode* p = types->head(); p; p = types->next(p))
 516       if (p->type->validate(item))
 517          return true;
 518    
 519    return false;
 520 }
 521 
 522 Item *RPTypeUnion::typeCast(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 523    Item *w;
 524    for (RPTypeNode* p = types->head(); p; p = types->next(p)) {
 525       w = p->type->typeCast(item);
 526       if (w)
 527          return w;
 528    }
 529    
 530    return NULL;
 531 }
 532 
 533 const char *RPTypeUnion::name() {
     /* [<][>][^][v][top][bottom][index][help] */
 534    if (!_name) {
 535       char buffer[1024];
 536       strcpy(buffer, "union ");
 537       for (RPTypeNode *n = types->head(); n; ) {
 538          strcat(buffer, n->type->name());
 539          n = types->next(n);
 540          if (n)
 541             strcat(buffer, ", ");
 542       }
 543       _name = strdup(buffer);
 544    }   
 545    return _name;
 546 }
 547 
 548 ////////////////////////////// RPTypeRange ////////////////////
 549 
 550 bool RPTypeRange::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 551    if (typeid(*item) == typeid(ItemRange))
 552       return type->validate(((ItemRange*) item)->begin)
 553          && type->validate(((ItemRange*) item)->end)
 554          && (*((ItemRange*) item)->begin) <= (*((ItemRange*) item)->end);
 555    return false;
 556 }
 557 
 558 Item *RPTypeRange::typeCast(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 559    Item *w = NULL;
 560 
 561    if (type->validate(item))
 562       w = item->dup();
 563    else
 564       w = type->typeCast(item);
 565 
 566    if (w)
 567       return new ItemRange(w, w->dup());
 568    
 569    return NULL;
 570 }
 571 
 572 ////////////////////////////// RPTypeList ////////////////////
 573 
 574 bool RPTypeList::validate(const Item *item) const {
     /* [<][>][^][v][top][bottom][index][help] */
 575    if (typeid(*item) == typeid(ItemList))
 576       return validate((ItemList*) item);
 577    return false;
 578 }
 579 bool RPTypeList::validate(ItemList *l) const {
     /* [<][>][^][v][top][bottom][index][help] */
 580    Item *w;
 581 
 582    if (! (min_elms <= l->size() && l->size() <= max_elms))
 583       return false;
 584 
 585    for (Item *item = l->head(); item; item = l->next(item))
 586       if (! type->validate(item)) {
 587          w = type->typeCast(item);
 588          if (w) {
 589             l->insertAfter(item, w);
 590             l->remove(item);
 591             delete item;
 592             item = w;
 593          } else
 594             return false;
 595       }
 596 
 597    return true;
 598 }
 599 

/* [<][>][^][v][top][bottom][index][help] */