ACE/ace/XML_Utils/XMLSchema/Writer.hpp

   1 // file      : XMLSchema/Writer.hpp
   2 // author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
   3 #ifndef XMLSCHEMA_WRITER_HPP
   4 #define XMLSCHEMA_WRITER_HPP
   5
   6 #include <sstream>
   7
   8 #include <ace/XML_Utils/XSCRT/Writer.hpp>
   9
  10 #include <ace/XML_Utils/XMLSchema/Types.hpp>
  11 #include <ace/XML_Utils/XMLSchema/Traversal.hpp>
  12
  13 #include <iostream>
  14
  15 namespace XMLSchema
  16 {
  17   namespace Writer
  18   {
  19     template <typename T, typename C>
  20     struct FundamentalType : Traversal::Traverser<T>,
  21                              virtual XSCRT::Writer<C>
  22     {
  23       FundamentalType (XSCRT::XML::Element<C>& e)
  24           : XSCRT::Writer<C> (e)
  25       {
  26       }
  27
  28       using XSCRT::Writer<C>::top_;
  29       using XSCRT::Writer<C>::attr_;
  30
  31       virtual void
  32       traverse (T const& o)
  33       {
  34         using namespace XSCRT::XML;
  35
  36         std::basic_ostringstream<C> os;
  37
  38         os << o;
  39
  40         if (Attribute<C>* a = attr_ ())
  41         {
  42           a->value (os.str ());
  43         }
  44         else
  45         {
  46           top_().value (os.str ());
  47         }
  48       }
  49
  50     protected:
  51       virtual void
  52       traverse (T &t)
  53       {
  54         Traversal::Traverser<T>::traverse (t);
  55       }
  56
  57       FundamentalType ()
  58       {
  59       }
  60     };
  61
  62     template<typename C>
  63     struct FundamentalType <XSCRT::FundamentalType<bool>, C> :
  64       Traversal::Traverser<XSCRT::FundamentalType<bool> >,
  65       virtual XSCRT::Writer<C>
  66     {
  67       FundamentalType (XSCRT::XML::Element<C> &e)
  68         : XSCRT::Writer<C> (e)
  69       {
  70       }
  71
  72       using XSCRT::Writer<C>::top_;
  73       using XSCRT::Writer<C>::attr_;
  74
  75       virtual void
  76       traverse (XSCRT::FundamentalType<bool> const &o)
  77       {
  78         using namespace XSCRT::XML;
  79
  80         std::basic_ostringstream<C> os;
  81
  82         if (o)
  83           {
  84             os << "true";
  85           }
  86         else
  87           {
  88             os << "false";
  89           }
  90
  91         if (Attribute<C>* a = attr_ ())
  92         {
  93           a->value (os.str ());
  94         }
  95         else
  96         {
  97           top_().value (os.str ());
  98         }
  99       }
 100
 101     protected:
 102       virtual void
 103       traverse (XSCRT::FundamentalType<bool> &t)
 104       {
 105         Traversal::Traverser<XSCRT::FundamentalType<bool> >::traverse (t);
 106       }
 107
 108       FundamentalType ()
 109       {
 110       }
 111     };
 112
 113
 114     template <typename C>
 115     struct IDREF : Traversal::Traverser<XMLSchema::IDREF<C> >,
 116                    virtual XSCRT::Writer<C>
 117     {
 118       IDREF (XSCRT::XML::Element<C>& e)
 119           : XSCRT::Writer<C> (e)
 120       {
 121       }
 122
 123       virtual void
 124       traverse (
 125         typename Traversal::Traverser<XMLSchema::IDREF<C> >::Type const& o)
 126       {
 127         using namespace XSCRT::XML;
 128
 129         if (Attribute<C>* a = XSCRT::Writer<C>::attr_ ())
 130         {
 131           a->value (o.id ());
 132         }
 133         else
 134         {
 135           XSCRT::Writer<C>::top_().value (o.id ());
 136         }
 137       }
 138
 139     protected:
 140
 141       virtual void
 142       traverse (typename Traversal::Traverser<XMLSchema::IDREF<C> >::Type &o)
 143       {
 144         Traversal::Traverser<XMLSchema::IDREF<C> >::traverse (o);
 145       }
 146
 147       IDREF ()
 148       {
 149       }
 150     };
 151   }
 152 }
 153
 154 #endif  // XMLSCHEMA_WRITER_HPP