ACE/ace/XML_Utils/XSCRT/XMLSchema.hpp

   1 // file      : XSCRT/XMLSchema.hpp
   2 // author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
   3 #ifndef XSCRT_XMLSCHEMA_HPP
   4 #define XSCRT_XMLSCHEMA_HPP
   5
   6 #include <string>
   7 // #include <iostream> //@@ tmp
   8
   9 #include "ace/XML_Utils/XMLSchema/XSCRT/Elements.hpp"
  10
  11 namespace XMLSchema
  12 {
  13   typedef XSCRT::FundamentalType<signed char> byte;
  14   typedef XSCRT::FundamentalType<unsigned char> unsignedByte;
  15
  16   typedef XSCRT::FundamentalType<short> short_;
  17   typedef XSCRT::FundamentalType<unsigned short> unsignedShort;
  18
  19   typedef XSCRT::FundamentalType<int> int_;
  20   typedef XSCRT::FundamentalType<unsigned int> unsignedInt;
  21
  22   typedef XSCRT::FundamentalType<long long> long_;
  23   typedef XSCRT::FundamentalType<unsigned long long> unsignedLong;
  24
  25   //@@ It would be nice to use some arbitrary-length integer class.
  26   //
  27   typedef long_ decimal;
  28   typedef decimal integer;
  29   typedef integer nonPositiveInteger;
  30   typedef integer nonNegativeInteger;
  31   typedef nonNegativeInteger positiveInteger;
  32   typedef nonPositiveInteger negativeInteger;
  33
  34
  35   typedef XSCRT::FundamentalType<bool> boolean;
  36
  37   typedef XSCRT::FundamentalType<float> float_;
  38   typedef XSCRT::FundamentalType<double> double_;
  39
  40   // Just to make GCC 3.3 and other broken compilers shutup.
  41   //
  42   using std::basic_string;
  43
  44
  45   template <typename C>
  46   class string : public XSCRT::Type, public basic_string<C>
  47   {
  48   protected:
  49     typedef basic_string<C> Base__ ;
  50
  51   public:
  52     //@@ VC6 does not inject XSCRT::Type into the scope so I have
  53     //   to qualify it all the time.
  54     //
  55     string () = default;
  56
  57     string (XSCRT::XML::Element<C> const& e)
  58         : Base__ (e.value ())
  59     {
  60     }
  61
  62     string (XSCRT::XML::Attribute<C> const& a)
  63         : Base__ (a.value ())
  64     {
  65     }
  66
  67     string (Base__ const& x)
  68         : Base__ (x)
  69     {
  70     }
  71
  72     string&
  73     operator= (Base__ const& x)
  74     {
  75       static_cast<Base__&> (*this) = x;
  76       return *this;
  77     }
  78   };
  79
  80
  81   template <typename C>
  82   class normalizedString : public string<C>
  83   {
  84   protected:
  85     typedef typename string<C>::Base__ Base__;
  86
  87   public:
  88     normalizedString () = default;
  89
  90     normalizedString (XSCRT::XML::Element<C> const& e)
  91         : string<C> (e)
  92     {
  93     }
  94
  95     normalizedString (XSCRT::XML::Attribute<C> const& a)
  96         : string<C> (a)
  97     {
  98     }
  99
 100     normalizedString (Base__ const& x)
 101         : string<C> (x)
 102     {
 103     }
 104
 105     normalizedString&
 106     operator= (Base__ const& x)
 107     {
 108       static_cast<Base__&> (*this) = x;
 109       return *this;
 110     }
 111   };
 112
 113
 114   template <typename C>
 115   class token : public normalizedString<C>
 116   {
 117   protected:
 118     typedef typename normalizedString<C>::Base__ Base__;
 119
 120   public:
 121     token () = default;
 122
 123     token (XSCRT::XML::Element<C> const& e)
 124         : normalizedString<C> (e)
 125     {
 126     }
 127
 128     token (XSCRT::XML::Attribute<C> const& a)
 129         : normalizedString<C> (a)
 130     {
 131     }
 132
 133     token (Base__ const& x)
 134         : normalizedString<C> (x)
 135     {
 136     }
 137
 138     token&
 139     operator= (Base__ const& x)
 140     {
 141       static_cast<Base__&> (*this) = x;
 142       return *this;
 143     }
 144   };
 145
 146
 147   template <typename C>
 148   class NMTOKEN : public token<C>
 149   {
 150   protected:
 151     typedef typename token<C>::Base__ Base__;
 152
 153   public:
 154     NMTOKEN () = default;
 155
 156     NMTOKEN (XSCRT::XML::Element<C> const& e)
 157         : token<C> (e)
 158     {
 159     }
 160
 161     NMTOKEN (XSCRT::XML::Attribute<C> const& a)
 162         : token<C> (a)
 163     {
 164     }
 165
 166     NMTOKEN (Base__ const& x)
 167         : token<C> (x)
 168     {
 169     }
 170
 171     NMTOKEN&
 172     operator= (Base__ const& x)
 173     {
 174       static_cast<Base__&> (*this) = x;
 175       return *this;
 176     }
 177   };
 178
 179   template <typename C>
 180   class Name: public token<C>
 181   {
 182   protected:
 183     typedef typename token<C>::Base__ Base__;
 184
 185   public:
 186     Name() = default;
 187
 188     Name(XSCRT::XML::Element<C> const& e)
 189         : token<C> (e)
 190     {
 191     }
 192
 193     Name(XSCRT::XML::Attribute<C> const& a)
 194         : token<C> (a)
 195     {
 196     }
 197
 198     Name(Base__ const& x)
 199         : token<C> (x)
 200     {
 201     }
 202
 203     Name&
 204     operator= (Base__ const& x)
 205     {
 206       static_cast<Base__&> (*this) = x;
 207       return *this;
 208     }
 209   };
 210
 211
 212   template <typename C>
 213   class NCName: public Name<C>
 214   {
 215   protected:
 216     typedef typename Name<C>::Base__ Base__;
 217
 218   public:
 219     NCName() = default;
 220
 221     NCName(XSCRT::XML::Element<C> const& e)
 222         : Name<C> (e)
 223     {
 224     }
 225
 226     NCName(XSCRT::XML::Attribute<C> const& a)
 227         : Name<C> (a)
 228     {
 229     }
 230
 231     NCName(Base__ const& x)
 232         : Name<C> (x)
 233     {
 234     }
 235
 236     NCName&
 237     operator= (Base__ const& x)
 238     {
 239       static_cast<Base__&> (*this) = x;
 240       return *this;
 241     }
 242   };
 243
 244   template <typename C>
 245   class QName: public Name<C>
 246   {
 247   protected:
 248     typedef typename Name<C>::Base__ Base__;
 249
 250   public:
 251     QName() = default;
 252
 253     QName(XSCRT::XML::Element<C> const& e)
 254         : Name<C> (e)
 255     {
 256     }
 257
 258     QName(XSCRT::XML::Attribute<C> const& a)
 259         : Name<C> (a)
 260     {
 261     }
 262
 263     QName(Base__ const& x)
 264         : Name<C> (x)
 265     {
 266     }
 267
 268     QName&
 269     operator= (Base__ const& x)
 270     {
 271       static_cast<Base__&> (*this) = x;
 272       return *this;
 273     }
 274   };
 275
 276   template <typename C>
 277   struct IdentityProvider : XSCRT::IdentityProvider
 278   {
 279     IdentityProvider (NCName<C> const& id)
 280         : id_ (id)
 281     {
 282     }
 283
 284     virtual bool
 285     before (XSCRT::IdentityProvider const& y) const
 286     {
 287       return id_ < dynamic_cast<IdentityProvider const&> (y).id_;
 288     }
 289
 290   private:
 291     NCName<C> const& id_;
 292
 293   private:
 294     IdentityProvider (IdentityProvider const&);
 295
 296     IdentityProvider&
 297     operator= (IdentityProvider const&);
 298   };
 299
 300
 301   template <typename C>
 302   class ID : public NCName<C>
 303   {
 304   protected:
 305     typedef typename NCName<C>::Base__ Base__;
 306
 307   public:
 308     ~ID()
 309     {
 310       unregister_id ();
 311     }
 312
 313     ID ()
 314         : id_provider_ (*this)
 315     {
 316     }
 317
 318     ID (XSCRT::XML::Element<C> const& e)
 319         : NCName<C> (e), id_provider_ (*this)
 320     {
 321     }
 322
 323     ID (XSCRT::XML::Attribute<C> const& a)
 324         : NCName<C> (a), id_provider_ (*this)
 325     {
 326     }
 327
 328     ID (ID const& x)
 329         :  NCName<C> (x), id_provider_ (*this)
 330     {
 331     }
 332
 333     ID (Base__ const& x)
 334         :  NCName<C> (x), id_provider_ (*this)
 335     {
 336     }
 337
 338     ID&
 339     operator= (Base__ const& x)
 340     {
 341       unregister_id ();
 342
 343       static_cast<NCName<C>&>(*this) = x;
 344
 345       register_id ();
 346
 347       return *this;
 348     }
 349
 350     ID&
 351     operator= (ID const& x)
 352     {
 353       unregister_id ();
 354
 355       static_cast<NCName<C>&>(*this) = static_cast<NCName<C> const&>(x);
 356
 357       register_id ();
 358
 359       return *this;
 360     }
 361
 362   public:
 363     using NCName<C>::container;
 364
 365     virtual void
 366     container (XSCRT::Type* c)
 367     {
 368       unregister_id ();
 369
 370       NCName<C>::container (c);
 371
 372       register_id ();
 373     }
 374
 375   private:
 376     using NCName<C>::empty;
 377     using NCName<C>::root;
 378
 379     void
 380     register_id ()
 381     {
 382       if (container () != this && !empty ())
 383       {
 384         //std::wcerr << "registering " << container ()
 385         //           << " as '" << *this
 386         //           << "' on " << container () << std::endl;
 387         container ()->register_id (id_provider_, container ());
 388       }
 389     }
 390
 391     void
 392     unregister_id ()
 393     {
 394       if (container () != this && !empty ())
 395       {
 396         //std::wcerr << "un-registering " << container ()
 397         //           << " as '" << *this
 398         //           << "' on " << container () << std::endl;
 399         container ()->unregister_id (id_provider_);
 400       }
 401     }
 402
 403   private:
 404     IdentityProvider<C> id_provider_;
 405   };
 406
 407   struct IDREF_Base : public XSCRT::Type
 408   {
 409     virtual XSCRT::Type*
 410     get () const = 0;
 411   };
 412
 413   template <typename C>
 414   class IDREF : public IDREF_Base
 415   {
 416   public:
 417     IDREF ()
 418         : id_provider_ (id_)
 419     {
 420     }
 421
 422     IDREF (XSCRT::XML::Element<C> const& e)
 423         : id_ (e), id_provider_ (id_)
 424     {
 425     }
 426
 427     IDREF (XSCRT::XML::Attribute<C> const& a)
 428         : id_ (a), id_provider_ (id_)
 429     {
 430     }
 431
 432     IDREF (IDREF const& x)
 433         : id_ (x.id_), id_provider_ (id_)
 434     {
 435     }
 436
 437     IDREF (basic_string<C> const& id)
 438         : id_ (id), id_provider_ (id_)
 439     {
 440     }
 441
 442     IDREF&
 443     operator= (IDREF const& x)
 444     {
 445       id_ = x.id_;
 446       return *this;
 447     }
 448
 449     IDREF&
 450     operator= (basic_string<C> const& x)
 451     {
 452       id_ = x;
 453       return *this;
 454     }
 455
 456   public:
 457     XSCRT::Type*
 458     operator-> () const
 459     {
 460       return get ();
 461     }
 462
 463     XSCRT::Type&
 464     operator* () const
 465     {
 466       return *(get ());
 467     }
 468
 469     virtual XSCRT::Type*
 470     get () const
 471     {
 472       if (!id_.empty () && container () != this)
 473       {
 474         return root ()->lookup_id (id_provider_);
 475       }
 476       else
 477       {
 478         return 0;
 479       }
 480     }
 481
 482     // conversion to bool
 483     //
 484     typedef XSCRT::Type* (IDREF::*bool_convertable)() const;
 485
 486     operator bool_convertable () const
 487     {
 488       return get () ? &IDREF::operator-> : 0;
 489     }
 490
 491   private:
 492     NCName<C> id_;
 493     IdentityProvider<C> id_provider_;
 494   };
 495 }
 496
 497 // Traversal
 498 //
 499
 500 #include "ace/XML_Utils/XSCRT/Traversal.hpp"
 501
 502 namespace XMLSchema
 503 {
 504   namespace Traversal
 505   {
 506     template <typename T>
 507     struct Traverser : XSCRT::Traversal::Traverser<T, XSCRT::Type>,
 508                        XSCRT::Traversal::Traverser<IDREF_Base, XSCRT::Type>
 509     {
 510       typedef
 511       T
 512       Type;
 513
 514       virtual void
 515       traverse (XMLSchema::IDREF_Base& r)
 516       {
 517         if (r.get ()) dispatch (*(r.get ()));
 518       }
 519     };
 520
 521     typedef Traverser<byte> byte;
 522     typedef Traverser<unsignedByte> unsignedByte;
 523
 524     typedef Traverser<short_> short_;
 525     typedef Traverser<unsignedShort> unsignedShort;
 526
 527     typedef Traverser<int_> int_;
 528     typedef Traverser<unsignedInt> unsignedInt;
 529
 530     typedef Traverser<long_> long_;
 531     typedef Traverser<unsignedLong> unsignedLong;
 532
 533     typedef Traverser<boolean> boolean;
 534
 535     typedef Traverser<float_> float_;
 536     typedef Traverser<double_> double_;
 537
 538     template <typename C>
 539     struct string : Traverser<XMLSchema::string<C> >
 540     {
 541     };
 542
 543     template <typename C>
 544     struct ID : Traverser<XMLSchema::ID<C> >
 545     {
 546     };
 547   }
 548 }
 549
 550
 551 // ExtendedTypeInfo for XML Schema types
 552 //
 553
 554 #include "ace/XML_Utils/XSCRT/ExtendedTypeInfo.hpp"
 555
 556 namespace XMLSchema
 557 {
 558   template <typename C>
 559   struct TypeInfoInitializer
 560   {
 561     TypeInfoInitializer (XSCRT::ExtendedTypeInfoMap&);
 562   };
 563 }
 564
 565 #include "ace/XML_Utils/XSCRT/XMLSchema.ipp"
 566 #include "ace/XML_Utils/XSCRT/XMLSchema.tpp"
 567
 568 #endif  // XSCRT_XMLSCHEMA_HPP