ComplexType Class Reference

#include <ComplexType.h>

Inheritance diagram for ComplexType:

Inheritance graph
[legend]
Collaboration diagram for ComplexType:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 ComplexType (const Wsdl &wsdl, const Xml::XmlNode &node, const std::string &name="", const std::string &ns_prefix="")
 ~ComplexType ()
const std::string & Name () const
const std::string Documentation () const
int NumberOfMembers () const
bool GetRef (std::string &ref) const
std::list< std::pair
< std::string, Xml::XmlNode > > 		GetMembers () const
std::list< std::pair
< std::string, Xml::XmlNode > > 		GetAttributes () const
void CreateInterface (FILE *fil, int lvl=1) const
void CreateImplementation (FILE *fil) const
const std::string CName () const
bool OkToGenerate () const
void SetGenerated (bool x=true)
bool IsGenerated () const
bool IsSequence () const
bool IsAll () const
bool IsComplexContent () const
bool IsArray () const
bool IsMixed () const

Static Public Member Functions

static void ShowGenerated ()

Private Member Functions

void reset_members (std::list< std::pair< std::string, Xml::XmlNode > > &members, std::list< std::pair< std::string, Xml::XmlNode > > &attrs, FILE *fil) const
void from_xml (std::list< std::pair< std::string, Xml::XmlNode > > &members, std::list< std::pair< std::string, Xml::XmlNode > > &attrs, FILE *fil) const
void to_string (std::list< std::pair< std::string, Xml::XmlNode > > &members, std::list< std::pair< std::string, Xml::XmlNode > > &attrs, FILE *fil) const
Xml::XmlNode Start () const

Private Attributes

std::string m_name
bool m_b_is_sequence
bool m_b_is_all
bool m_b_complexContent
bool m_b_is_array
bool m_b_is_mixed
std::string m_extends
std::string m_extends_cls

Static Private Attributes

static std::map< std::string,
bool > 		m_b_generated

Detailed Description

Definition at line 34 of file ComplexType.h.

Constructor & Destructor Documentation

ComplexType::ComplexType ( const Wsdl &  wsdl,
const Xml::XmlNode &  node,
const std::string &  name = "",
const std::string &  ns_prefix = "" 
)

Definition at line 38 of file ComplexType.cpp.

References m_b_complexContent, m_b_is_all, m_b_is_array, m_b_is_mixed, m_b_is_sequence, m_extends, m_extends_cls, TypeBase::m_node, TypeBase::m_wsdl, Wsdl::NamespaceFromHref(), TypeBase::SetType(), Start(), and TypeBase::Type().

00039 : TypeBase(wsdl, node, ns_prefix, Split(name).Type)
00040 , m_name(!name.empty() ? name : node.PropertyExists("name") ? node.GetProperty("name") : "")
00041 , m_b_is_sequence(false)
00042 , m_b_is_all(false)
00043 , m_b_complexContent(false)
00044 , m_b_is_array(false)
00045 , m_b_is_mixed(false)
00046 {
00047         Xml::XmlNode start = Start();
00048         if (m_node.PropertyExists("mixed") && m_node.GetProperty("mixed") == "true")
00049         {
00050                 m_b_is_mixed = true;
00051         }
00052         if (start.PropertyExists("base"))
00053         {
00054                 m_extends = start.GetProperty("base");
00055                 std::string ns_href = m_node.GetNsMap()[Split(m_extends).NS];
00056                 if (ns_href.empty())
00057                         m_extends_cls = Split(m_extends).CName1up;
00058                 else
00059                         m_extends_cls = m_wsdl.NamespaceFromHref(ns_href) + "::" + Split(m_extends).CName1up;
00060         }
00061         // check 'sequence'
00062         {
00063                 Xml::XmlNode n(start, "sequence");
00064                 if (n)
00065                         m_b_is_sequence = true;
00066         }
00067         // check 'all'
00068         {
00069                 Xml::XmlNode n(start, "all");
00070                 if (n)
00071                         m_b_is_all = true;
00072         }
00073         //
00074         {
00075 
00076                 Xml::XmlNode n(m_node, "complexContent");
00077                 if (n)
00078                 {
00079                         m_b_complexContent = true;
00080                         Xml::XmlNode n2(n, "restriction");
00081                         if (n2)
00082                         {
00083                                 if (n2.PropertyExists("base") && Split(n2.GetProperty("base")).Type == "Array")
00084                                 {
00085                                         Xml::XmlNode n3(n2, "attribute");
00086                                         if (n3 && n3.PropertyExists("arrayType"))
00087                                         {
00088                                                 std::string tmp = n3.GetProperty("arrayType");
00089                                                 Parse pa(tmp, "[]");
00090                                                 tmp = pa.getword();
00091                                                 SetType( tmp );
00092                                                 m_b_is_array = true;
00093                                         }
00094                                 }
00095                         }
00096                 }
00097         }
00098 }

ComplexType::~ComplexType (  ) 

Definition at line 101 of file ComplexType.cpp.

00102 {
00103 }

Member Function Documentation

const std::string& ComplexType::Name (  )  const [inline]

Definition at line 40 of file ComplexType.h.

References m_name.

Referenced by CreateImplementation(), CreateInterface(), and OkToGenerate().

00040 { return m_name; }

const std::string ComplexType::Documentation (  )  const

Definition at line 183 of file ComplexType.cpp.

References TypeBase::Documentation(), and TypeBase::m_node.

Referenced by Wsdl::CreateInterface().

00184 {
00185         return TypeBase::Documentation(m_node);
00186 }

int ComplexType::NumberOfMembers (  )  const

Definition at line 106 of file ComplexType.cpp.

References m_b_is_sequence, and Start().

Referenced by Wsdl::GetMessageParameters().

00107 {
00108         Xml::XmlNode n(Start(), m_b_is_sequence ? "sequence" : "all");
00109         int q = 0;
00110         if (n)
00111         {
00112                 Xml::XmlNode n2(n, "element");
00113                 while (n2)
00114                 {
00115                         q++;
00116                         ++n2;
00117                 }
00118         }
00119         return q;
00120 }

bool ComplexType::GetRef ( std::string &  ref  )  const

Definition at line 123 of file ComplexType.cpp.

References m_b_is_sequence, and Start().

Referenced by Wsdl::GetMessageParameters().

00124 {
00125         Xml::XmlNode n(Start(), m_b_is_sequence ? "sequence" : "all");
00126         if (n)
00127         {
00128                 Xml::XmlNode n2(n, "element");
00129                 while (n2)
00130                 {
00131                         if (n2.PropertyExists("ref"))
00132                         {
00133                                 ref = n2.GetProperty("ref");
00134                                 return true;
00135                         }
00136                         ++n2;
00137                 }
00138         }
00139         return false;
00140 }

std::list< std::pair< std::string, Xml::XmlNode > > ComplexType::GetMembers (  )  const

Definition at line 143 of file ComplexType.cpp.

References m_b_is_sequence, and Start().

Referenced by CreateImplementation(), CreateInterface(), Wsdl::GetMessageParameters(), and OkToGenerate().

00144 {
00145         std::list<std::pair<std::string, Xml::XmlNode> > vec;
00146         Xml::XmlNode n1(Start(), m_b_is_sequence ? "sequence" : "all");
00147         if (n1)
00148         {
00149                 Xml::XmlNode n(n1, "element");
00150                 while (n)
00151                 {
00152                         if (n.PropertyExists("ref"))
00153                         {
00154                                 std::string name = n.GetProperty("ref");
00155                                 vec.push_back(std::pair<std::string, Xml::XmlNode>(name, n));
00156                         }
00157                         else
00158                         {
00159                                 std::string name = n.GetProperty("name");
00160                                 vec.push_back(std::pair<std::string, Xml::XmlNode>(name, n));
00161                         }
00162                         ++n;
00163                 }
00164         }
00165         return vec;
00166 }

std::list< std::pair< std::string, Xml::XmlNode > > ComplexType::GetAttributes (  )  const

Definition at line 169 of file ComplexType.cpp.

References Start().

Referenced by CreateImplementation(), CreateInterface(), and OkToGenerate().

00170 {
00171         std::list<std::pair<std::string, Xml::XmlNode> > vec;
00172         Xml::XmlNode n(Start(), "attribute");
00173         while (n)
00174         {
00175                 std::string name = n.GetProperty("name");
00176                 vec.push_back(std::pair<std::string, Xml::XmlNode>(name, n));
00177                 ++n;
00178         }
00179         return vec;
00180 }

void ComplexType::CreateInterface ( FILE *  fil,
int  lvl = 1 
) const

Definition at line 259 of file ComplexType.cpp.

References Attribute::CName(), Element::CName(), CName(), Attribute::CName1up(), Element::CName1up(), Wsdl::ComplexTypes(), SimpleType::CreateInterface(), CreateInterface(), TypeBase::CType(), Attribute::CType_decl(), Element::CType_decl(), Attribute::CType_in(), Element::CType_in(), Attribute::CType_out(), Element::CType_out(), Element::Documentation(), Wsdl::FindComplexType(), Wsdl::FindSimpleType(), Wsdl::GetApplication(), GetAttributes(), GetMembers(), Wsdl::GetParent(), Element::IsComplexType(), Element::IsVector(), Application::ListType(), m_b_complexContent, m_b_is_array, m_b_is_mixed, m_b_is_sequence, m_extends, m_extends_cls, TypeBase::m_ns_href, TypeBase::m_wsdl, Name(), TypeBase::NsHref(), and Wsdl::SimpleTypes().

Referenced by Wsdl::CreateInterface(), and CreateInterface().

00260 {
00261         std::string prefix;
00262         for (int i = 0; i < lvl; i++)
00263                 prefix += "\t";
00264         if (m_b_complexContent)
00265         {
00266                 if (m_b_is_array)
00267                 {
00268                         fprintf(fil, "%stypedef %s<%s> %s;\n", prefix.c_str(), TypeBase::CType().c_str(), m_wsdl.GetApplication().ListType().c_str(), CName().c_str());
00269                 }
00270         }
00271 
00272         std::list<std::pair<std::string, Xml::XmlNode> > members = GetMembers();
00273         std::list<std::pair<std::string, Xml::XmlNode> > attrs = GetAttributes();
00274         if (members.empty() && attrs.empty() && !m_b_is_mixed)
00275                 return;
00276 
00277         // parent
00278         std::string parent = m_wsdl.GetParent(NsHref(), Name());
00279 
00280         // class
00281         if (m_extends.empty())
00282         {
00283                 fprintf(fil, "%sclass %s\n%s{\n", prefix.c_str(), CName().c_str(), prefix.c_str());
00284         }
00285         else
00286         {
00287                 fprintf(fil, "%sclass %s : public %s\n%s{\n", prefix.c_str(), CName().c_str(), m_extends_cls.c_str(), prefix.c_str());
00288         }
00289 
00290         // internal types
00291         try
00292         {
00293                 const std::list<std::string>& ref = m_wsdl.ComplexTypes(NsHref());
00294                 for (std::list<std::string>::const_iterator it = ref.begin(); it != ref.end(); it++)
00295                 {
00296                         std::string parent = m_wsdl.GetParent(NsHref(), *it);
00297                         if (parent == Name())
00298                         {
00299                                 fprintf(fil, "%spublic:\n", prefix.c_str());
00300                                 Xml::XmlNode n = m_wsdl.FindComplexType( m_ns_href, *it );
00301                                 ComplexType t(m_wsdl, n, *it, NsHref());
00302                                 t.CreateInterface(fil, lvl + 1);
00303                         }
00304                 }
00305         } catch (const Exception&) {}
00306         try
00307         {
00308                 const std::list<std::string>& ref = m_wsdl.SimpleTypes(NsHref());
00309                 for (std::list<std::string>::const_iterator it = ref.begin(); it != ref.end(); it++)
00310                 {
00311                         std::string parent = m_wsdl.GetParent(NsHref(), *it);
00312                         if (parent == Name())
00313                         {
00314                                 fprintf(fil, "%spublic:\n", prefix.c_str());
00315                                 Xml::XmlNode n = m_wsdl.FindSimpleType( m_ns_href, *it );
00316                                 SimpleType t(m_wsdl, n, *it, NsHref());
00317                                 t.CreateInterface(fil, lvl + 1);
00318                         }
00319                 }
00320         } catch (const Exception&) {}
00321 
00322         // begin methods
00323         fprintf(fil, "%spublic:\n", prefix.c_str());
00324         // default constructor
00325         fprintf(fil, "%s\t%s();\n", prefix.c_str(), CName().c_str());
00326         // create from Xml::XmlNode constructor
00327         fprintf(fil, "%s\t%s(const Xml::XmlNode& it);\n", prefix.c_str(), CName().c_str());
00328         // destructor
00329         fprintf(fil, "%s\tvirtual ~%s() {}\n", prefix.c_str(), CName().c_str());
00330         fprintf(fil, "\n");
00331         // From Xml
00332         fprintf(fil, "%s\tvoid FromXml(const Xml::XmlNode& it);\n", prefix.c_str());
00333         fprintf(fil, "\n");
00334         // ToString
00335         fprintf(fil, "%s\tconst std::string ToString(const std::string& name = \"\") const;\n", prefix.c_str());
00336         fprintf(fil, "\n");
00337         // IsSet
00338         {
00339                 fprintf(fil, "%s\tbool IsSet() const;\n", prefix.c_str());
00340                 fprintf(fil, "\n");
00341         }
00342         // get/set methods
00343         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00344         {
00345                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00346                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00347                 if (el.IsVector() || el.IsComplexType())
00348                 {
00349                         fprintf(fil, "%s\tconst %s Get%s() const;\n", prefix.c_str(), el.CType_out().c_str(), el.CName1up().c_str());
00350                         fprintf(fil, "%s\t%s Get%s();\n", prefix.c_str(), el.CType_out().c_str(), el.CName1up().c_str());
00351                         fprintf(fil, "%s\tvoid Set%s(%s %s);\n",
00352                                 prefix.c_str(), el.CName1up().c_str(), el.CType_in().c_str(), el.CName().c_str());
00353                 }
00354                 else
00355                 {
00356                         fprintf(fil, "%s\t%s Get%s() const;\n", prefix.c_str(), el.CType_out().c_str(), el.CName1up().c_str());
00357                         fprintf(fil, "%s\tvoid Set%s(%s %s);\n", prefix.c_str(), el.CName1up().c_str(),
00358                                 el.CType_in().c_str(), el.CName().c_str());
00359                 }
00360                 fprintf(fil, "\n");
00361         }
00362         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00363         {
00364                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00365                 Attribute attr(m_wsdl, ref.second, ref.first, NsHref());
00366 
00367                 fprintf(fil, "%s\t%s Get%s() const;\n", prefix.c_str(), attr.CType_out().c_str(), attr.CName1up().c_str());
00368 //              if (!attr.FixedIsSet())
00369                 {
00370                         fprintf(fil, "%s\tvoid Set%s(%s %s);\n", prefix.c_str(), attr.CName1up().c_str(),
00371                                 attr.CType_in().c_str(), attr.CName().c_str());
00372                 }
00373         }
00374         if (!attrs.empty())
00375                 fprintf(fil, "\n");
00376         if (m_b_is_mixed)
00377         {
00378                 fprintf(fil, "%s\tconst std::string& Get() const;\n", prefix.c_str());
00379                 fprintf(fil, "%s\tvoid Set(const std::string&);\n", prefix.c_str());
00380                 fprintf(fil, "\n");
00381         }
00382         // is_set methods
00383         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00384         {
00385                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00386                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00387                 if (el.IsVector() || el.IsComplexType())
00388                 {
00389                         // _is_set is calculated
00390                         fprintf(fil, "%s\tbool %sIsSet() const;\n", prefix.c_str(), el.CName1up().c_str());
00391                 }
00392                 else
00393                 {
00394                         fprintf(fil, "%s\tbool %sIsSet() const { return _element_%s_is_set; }\n", prefix.c_str(), el.CName1up().c_str(), el.CName().c_str());
00395                 }
00396         }
00397         if (!members.empty())
00398                 fprintf(fil, "\n");
00399         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00400         {
00401                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00402                 Attribute attr(m_wsdl, ref.second, ref.first, NsHref());
00403 
00404                 fprintf(fil, "%s\tbool %sIsSet() const { return _attribute_%s_is_set; }\n", prefix.c_str(), attr.CName1up().c_str(), attr.CName().c_str());
00405         }
00406         if (!attrs.empty())
00407                 fprintf(fil, "\n");
00408         // private
00409         fprintf(fil, "%sprivate:\n", prefix.c_str());
00410         // elements
00411         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00412         {
00413                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00414                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00415                 std::string doc = el.Documentation();
00416                 if (!doc.empty())
00417                         fprintf(fil, "%s\t/** %s */\n", prefix.c_str(), doc.c_str());
00418                 fprintf(fil, "%s\t%s _element_%s;\n", prefix.c_str(), el.CType_decl().c_str(), el.CName().c_str());
00419         }
00420         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00421         {
00422                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00423                 Attribute attr(m_wsdl, ref.second, ref.first, NsHref());
00424 
00425                 fprintf(fil, "%s\t%s _attribute_%s;\n", prefix.c_str(), attr.CType_decl().c_str(), attr.CName().c_str());
00426         }
00427         if (m_b_is_mixed)
00428         {
00429                 fprintf(fil, "%s\tstd::string m_mixed_content;\n", prefix.c_str());
00430         }
00431         // is_set members
00432         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00433         {
00434                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00435                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00436                 if (el.IsVector() || el.IsComplexType())
00437                 {
00438                         // _is_set is calculated
00439                 }
00440                 else
00441                 {
00442                         fprintf(fil, "%s\tbool _element_%s_is_set;\n", prefix.c_str(), el.CName().c_str());
00443                 }
00444         }
00445         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00446         {
00447                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00448                 Attribute attr(m_wsdl, ref.second, ref.first, NsHref());
00449 
00450                 fprintf(fil, "%s\tbool _attribute_%s_is_set;\n", prefix.c_str(), attr.CName().c_str());
00451         }
00452         //
00453         fprintf(fil, "%s};\n", prefix.c_str()); // End of class '%s'\n", CName().c_str());
00454         fprintf(fil, "\n");
00455 }

void ComplexType::CreateImplementation ( FILE *  fil  )  const

Definition at line 720 of file ComplexType.cpp.

References Attribute::CName(), Element::CName(), CName(), Attribute::CName1up(), Element::CName1up(), Attribute::CType_in(), Element::CType_in(), Attribute::CType_out(), Element::CType_out(), from_xml(), GetAttributes(), GetMembers(), Wsdl::GetParent(), Element::IsComplexType(), Element::IsVector(), m_b_is_mixed, m_b_is_sequence, TypeBase::m_wsdl, Name(), TypeBase::NsHref(), reset_members(), and to_string().

Referenced by Wsdl::CreateImplementation().

00721 {
00722         std::list<std::pair<std::string, Xml::XmlNode> > members = GetMembers();
00723         std::list<std::pair<std::string, Xml::XmlNode> > attrs = GetAttributes();
00724         if (members.empty() && attrs.empty() && !m_b_is_mixed)
00725                 return;
00726 
00727         std::string parent = m_wsdl.GetParent(NsHref(), Name());
00728         std::string tmp;
00729         while (!parent.empty())
00730         {
00731                 tmp = Split(parent).CName1up + "::" + tmp;
00732                 parent = m_wsdl.GetParent(NsHref(), parent);
00733         }
00734         std::string classname = tmp + CName();
00735 
00736         // default constructor
00737         fprintf(fil, "// -----------------------------------------------------------------------------\n");
00738         fprintf(fil, "%s::%s()\n", classname.c_str(), CName().c_str());
00739         reset_members(members, attrs, fil);
00740         fprintf(fil, "{\n");
00741         fprintf(fil, "}\n\n\n");
00742         // Xml::XmlNode constructor
00743         fprintf(fil, "// -----------------------------------------------------------------------------\n");
00744         fprintf(fil, "%s::%s(const Xml::XmlNode& it)\n", classname.c_str(), CName().c_str());
00745         reset_members(members, attrs, fil);
00746         fprintf(fil, "{\n");
00747         fprintf(fil, "\tFromXml(it);\n");
00748         fprintf(fil, "}\n\n\n");
00749         // From Xml
00750         fprintf(fil, "// -----------------------------------------------------------------------------\n");
00751         fprintf(fil, "void %s::FromXml(const Xml::XmlNode& it)\n{\n", classname.c_str());
00752         from_xml(members, attrs, fil);
00753         fprintf(fil, "}\n\n\n");
00754         // ToString
00755         fprintf(fil, "// -----------------------------------------------------------------------------\n");
00756         fprintf(fil, "const std::string %s::ToString(const std::string& name) const\n{\n", classname.c_str());
00757         to_string(members, attrs, fil);
00758         fprintf(fil, "}\n\n\n");
00759         // IsSet
00760         {
00761                 fprintf(fil, "// -----------------------------------------------------------------------------\n");
00762                 fprintf(fil, "bool %s::IsSet() const\n{\n", classname.c_str());
00763                 std::string prefix = "\treturn ";
00764                 for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00765                 {
00766                         const std::pair<std::string, Xml::XmlNode>& ref = *it;
00767                         Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00768                         fprintf(fil, "%s%sIsSet()", prefix.c_str(), el.CName1up().c_str());
00769                         prefix = " || ";
00770                 }
00771                 for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00772                 {
00773                         const std::pair<std::string, Xml::XmlNode>& ref = *it;
00774                         Attribute attr(m_wsdl, ref.second, "", NsHref());
00775                         fprintf(fil, "%s%sIsSet()", prefix.c_str(), attr.CName1up().c_str());
00776                         prefix = " || ";
00777                 }
00778                 if (m_b_is_mixed)
00779                 {
00780                         fprintf(fil, "%s!m_mixed_content.empty()", prefix.c_str());
00781                         prefix = " || ";
00782                 }
00783                 fprintf(fil, ";\n");
00784                 fprintf(fil, "}\n\n\n");
00785         }
00786         // get/set
00787         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00788         {
00789                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00790                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00791                 fprintf(fil, "// -----------------------------------------------------------------------------\n");
00792                 if (el.IsVector() || el.IsComplexType())
00793                 {
00794                         fprintf(fil, "const %s %s::Get%s() const\n{\n", el.CType_out().c_str(), classname.c_str(), el.CName1up().c_str());
00795                         fprintf(fil, "\treturn _element_%s;\n", el.CName().c_str());
00796                         fprintf(fil, "}\n\n\n");
00797                         fprintf(fil, "%s %s::Get%s()\n{\n", el.CType_out().c_str(), classname.c_str(), el.CName1up().c_str());
00798                         fprintf(fil, "\treturn _element_%s;\n", el.CName().c_str());
00799                         fprintf(fil, "}\n\n\n");
00800                         fprintf(fil, "void %s::Set%s(%s %s)\n{\n\t_element_%s = %s;\n}\n\n\n",
00801                                 classname.c_str(),
00802                                 el.CName1up().c_str(), el.CType_in().c_str(), el.CName().c_str(),
00803                                 el.CName().c_str(), el.CName().c_str());
00804                 }
00805                 else
00806                 {
00807                         fprintf(fil, "%s %s::Get%s() const\n{\n", el.CType_out().c_str(), classname.c_str(), el.CName1up().c_str());
00808                         fprintf(fil, "\treturn _element_%s;\n", el.CName().c_str());
00809                         fprintf(fil, "}\n\n\n");
00810                         fprintf(fil, "void %s::Set%s(%s %s)\n{\n", classname.c_str(), el.CName1up().c_str(),
00811                                 el.CType_in().c_str(), el.CName().c_str());
00812                         fprintf(fil, "\t_element_%s = %s;\n", el.CName().c_str(), el.CName().c_str());
00813                         fprintf(fil, "\t_element_%s_is_set = true;\n", el.CName().c_str());
00814                         fprintf(fil, "}\n\n\n");
00815                 }
00816         }
00817         // is_set
00818         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00819         {
00820                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00821                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00822                 if (el.IsVector() || el.IsComplexType())
00823                 {
00824                         // _is_set is calculated
00825                         fprintf(fil, "// -----------------------------------------------------------------------------\n");
00826                         fprintf(fil, "bool %s::%sIsSet() const\n{\n", classname.c_str(), el.CName1up().c_str());
00827                         if (el.IsVector())
00828                                 fprintf(fil, "\treturn !_element_%s.empty();\n", el.CName().c_str());
00829                         else
00830                                 fprintf(fil, "\treturn _element_%s.IsSet();\n", el.CName().c_str());
00831                         fprintf(fil, "}\n\n\n");
00832                 }
00833                 else
00834                 {
00835                 }
00836         }
00837         // attribute get/set
00838         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00839         {
00840                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00841                 Attribute attr(m_wsdl, ref.second, "", NsHref());
00842                 fprintf(fil, "// -----------------------------------------------------------------------------\n");
00843                 {
00844                         fprintf(fil, "%s %s::Get%s() const\n{\n", attr.CType_out().c_str(), classname.c_str(), attr.CName1up().c_str());
00845                         fprintf(fil, "\treturn _attribute_%s;\n", attr.CName().c_str());
00846                         fprintf(fil, "}\n\n\n");
00847 //                      if (!attr.FixedIsSet())
00848                         {
00849                                 fprintf(fil, "void %s::Set%s(%s %s)\n{\n", classname.c_str(), attr.CName1up().c_str(),
00850                                         attr.CType_in().c_str(), attr.CName().c_str());
00851                                 fprintf(fil, "\t_attribute_%s = %s;\n", attr.CName().c_str(), attr.CName().c_str());
00852                                 fprintf(fil, "\t_attribute_%s_is_set = true;\n", attr.CName().c_str());
00853                                 fprintf(fil, "}\n\n\n");
00854                         }
00855                 }
00856         }
00857         if (m_b_is_mixed)
00858         {
00859                 fprintf(fil, "// -----------------------------------------------------------------------------\n");
00860                 fprintf(fil, "const std::string& %s::Get() const\n", classname.c_str());
00861                 fprintf(fil, "{\n");
00862                 fprintf(fil, "\treturn m_mixed_content;\n");
00863                 fprintf(fil, "}\n\n\n");
00864                 fprintf(fil, "// -----------------------------------------------------------------------------\n");
00865                 fprintf(fil, "void %s::Set(const std::string& x)\n", classname.c_str());
00866                 fprintf(fil, "{\n");
00867                 fprintf(fil, "\tm_mixed_content = x;\n");
00868                 fprintf(fil, "}\n\n\n");
00869         }
00870 }

const std::string ComplexType::CName (  )  const

Definition at line 189 of file ComplexType.cpp.

References m_name.

Referenced by CreateImplementation(), and CreateInterface().

00190 {
00191         return Split(m_name).CName1up;
00192 }

bool ComplexType::OkToGenerate (  )  const

Definition at line 195 of file ComplexType.cpp.

References Wsdl::FindComplexType(), GetAttributes(), GetMembers(), Wsdl::GetParent(), Element::IsComplexType(), IsGenerated(), m_b_complexContent, m_b_is_array, m_b_is_sequence, TypeBase::m_ns_href, TypeBase::m_wsdl, Name(), TypeBase::NsHref(), and TypeBase::Type().

Referenced by Wsdl::CreateInterface().

00196 {
00197         Debug deb("OkToGenerate for '" + Name() + "' in ns '" + NsHref() + "'");
00198         if (m_b_complexContent)
00199         {
00200                 if (m_b_is_array)
00201                 {
00202                         try
00203                         {
00204                                 Xml::XmlNode n = m_wsdl.FindComplexType( m_ns_href, Type() );
00205                                 ComplexType t(m_wsdl, n, Split(Type()).Type, Split(Type()).NS);
00206                                 if (!t.IsGenerated())
00207                                 {
00208                                         return false;
00209                                 }
00210                         }
00211                         catch (const Exception& )
00212                         {
00213                         }
00214                         return true;
00215                 }
00216         }
00217         std::list<std::pair<std::string, Xml::XmlNode> > members = GetMembers();
00218         std::list<std::pair<std::string, Xml::XmlNode> > attrs = GetAttributes();
00219         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00220         {
00221                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00222                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00223                 if (el.IsComplexType())
00224                 {
00225                         Xml::XmlNode n = m_wsdl.FindComplexType( el.NsHref(), el.Type() );
00226                         ComplexType t(m_wsdl, n, Split(el.Type()).Type, Split(el.Type()).NS);
00227                         std::string parent = m_wsdl.GetParent(NsHref(), t.Name());
00228                         if (!t.IsGenerated() && parent != Name())
00229                         {
00230                                 return false;
00231                         }
00232                 }
00233                 else
00234                 {
00235                 }
00236         }
00237         return true;
00238 }

void ComplexType::SetGenerated ( bool  x = true  ) 

Definition at line 241 of file ComplexType.cpp.

References m_b_generated, and m_name.

Referenced by Wsdl::CreateInterface().

00242 {
00243         m_b_generated[m_name] = x; 
00244 }

bool ComplexType::IsGenerated (  )  const

Definition at line 247 of file ComplexType.cpp.

References m_b_generated, and m_name.

Referenced by Wsdl::CreateInterface(), and OkToGenerate().

00248 {
00249         std::map<std::string, bool>::const_iterator it = m_b_generated.find(m_name);
00250 
00251         if (it != m_b_generated.end())
00252         {
00253                 return true;
00254         }
00255         return false;
00256 }

bool ComplexType::IsSequence (  )  const [inline]

Definition at line 58 of file ComplexType.h.

References m_b_is_sequence.

Referenced by Wsdl::ParseComplexType().

00058 { return m_b_is_sequence; }

bool ComplexType::IsAll (  )  const [inline]

Definition at line 59 of file ComplexType.h.

References m_b_is_all.

Referenced by Wsdl::ParseComplexType().

00059 { return m_b_is_all; }

bool ComplexType::IsComplexContent (  )  const [inline]

Definition at line 60 of file ComplexType.h.

References m_b_complexContent.

00060 { return m_b_complexContent; }

bool ComplexType::IsArray (  )  const [inline]

Definition at line 61 of file ComplexType.h.

References m_b_is_array.

00061 { return m_b_is_array; }

bool ComplexType::IsMixed (  )  const [inline]

Definition at line 62 of file ComplexType.h.

References m_b_is_mixed.

00062 { return m_b_is_mixed; }

void ComplexType::ShowGenerated (  )  [static]

Definition at line 891 of file ComplexType.cpp.

References m_b_generated.

Referenced by main().

00892 {
00893         for (std::map<std::string, bool>::iterator it = m_b_generated.begin(); it != m_b_generated.end(); it++)
00894         {
00895                 std::cout << "generated: " << it -> first << std::endl;
00896         }
00897 }

void ComplexType::reset_members ( std::list< std::pair< std::string, Xml::XmlNode > > &  members,
std::list< std::pair< std::string, Xml::XmlNode > > &  attrs,
FILE *  fil 
) const [private]

Definition at line 458 of file ComplexType.cpp.

References Attribute::CName(), Element::CName(), Attribute::Default(), Attribute::DefaultIsSet(), Attribute::DefaultValue(), Element::DefaultValue(), Attribute::Fixed(), Attribute::FixedIsSet(), TypeBase::IsBuiltin(), Element::IsComplexType(), TypeBase::IsNumeric(), Element::IsVector(), m_b_is_sequence, m_extends, m_extends_cls, TypeBase::m_wsdl, and TypeBase::NsHref().

Referenced by CreateImplementation().

00459 {
00460         std::string prefix = ": ";
00461         if (!m_extends.empty())
00462         {
00463                 fprintf(fil, "%s%s()\n", prefix.c_str(), m_extends_cls.c_str());
00464                 prefix = ", ";
00465         }
00466         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00467         {
00468                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00469                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00470                 std::string def = el.DefaultValue();
00471                 if (el.IsBuiltin() && !def.empty())
00472                 {
00473                         fprintf(fil, "%s_element_%s(%s)\n", prefix.c_str(), el.CName().c_str(), el.DefaultValue().c_str());
00474                         prefix = ", ";
00475                 }
00476         }
00477         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00478         {
00479                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00480                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00481                 if (el.IsVector() || el.IsComplexType())
00482                 {
00483                         // _is_set is calculated
00484                 }
00485                 else
00486                 {
00487                         fprintf(fil, "%s_element_%s_is_set(false)\n", prefix.c_str(), el.CName().c_str());
00488                         prefix = ", ";
00489                 }
00490         }
00491         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00492         {
00493                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00494                 Attribute attr(m_wsdl, ref.second, "", NsHref());
00495                 if (attr.DefaultIsSet())
00496                 {
00497                         if (attr.IsNumeric())
00498                                 fprintf(fil, "%s_attribute_%s(%s)\n", prefix.c_str(), attr.CName().c_str(), attr.Default().c_str());
00499                         else
00500                                 fprintf(fil, "%s_attribute_%s(\"%s\")\n", prefix.c_str(), attr.CName().c_str(), attr.Default().c_str());
00501                         prefix = ", ";
00502                 }
00503                 else
00504                 if (attr.FixedIsSet())
00505                 {
00506                         if (attr.IsNumeric())
00507                                 fprintf(fil, "%s_attribute_%s(%s)\n", prefix.c_str(), attr.CName().c_str(), attr.Fixed().c_str());
00508                         else
00509                                 fprintf(fil, "%s_attribute_%s(\"%s\")\n", prefix.c_str(), attr.CName().c_str(), attr.Fixed().c_str());
00510                         prefix = ", ";
00511                 }
00512                 else
00513                 {
00514                         std::string def = attr.DefaultValue();
00515                         if (attr.IsBuiltin() && !def.empty())
00516                         {
00517                                 fprintf(fil, "%s_attribute_%s(%s)\n", prefix.c_str(), attr.CName().c_str(), attr.DefaultValue().c_str());
00518                                 prefix = ", ";
00519                         }
00520                 }
00521         }
00522         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00523         {
00524                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00525                 Attribute attr(m_wsdl, ref.second, "", NsHref());
00526                 if (attr.DefaultIsSet() || attr.FixedIsSet())
00527                         fprintf(fil, "%s_attribute_%s_is_set(true)\n", prefix.c_str(), attr.CName().c_str());
00528                 else
00529                         fprintf(fil, "%s_attribute_%s_is_set(false)\n", prefix.c_str(), attr.CName().c_str());
00530                 prefix = ", ";
00531         }
00532 }

void ComplexType::from_xml ( std::list< std::pair< std::string, Xml::XmlNode > > &  members,
std::list< std::pair< std::string, Xml::XmlNode > > &  attrs,
FILE *  fil 
) const [private]

Definition at line 535 of file ComplexType.cpp.

References Attribute::BaseType(), Element::BaseType(), Element::CName(), Attribute::CName1up(), Element::CName1up(), TypeBase::CType(), Element::IsComplexType(), Attribute::IsOptional(), Element::IsOptional(), Element::IsVector(), m_b_is_mixed, m_b_is_sequence, m_extends, m_extends_cls, m_name, TypeBase::m_wsdl, Attribute::Name(), Element::Name(), and TypeBase::NsHref().

Referenced by CreateImplementation().

00536 {       
00537         if (!m_extends.empty())
00538         {
00539                 fprintf(fil, "\t%s::FromXml(it);\n", m_extends_cls.c_str());
00540         }
00541         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00542         {
00543                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00544                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00545                 if (!el.IsOptional())
00546                 {
00547                         fprintf(fil, "\tif (!it.Exists(\"%s\"))\n", el.Name().c_str());
00548                         fprintf(fil, "\t\tthrow Xml::XmlException(\"missing required node in element '%s': %s\");\n", m_name.c_str(), el.Name().c_str());
00549                 }
00550                 if (el.IsVector())
00551                 {
00552                         fprintf(fil, "\t{\n");
00553                         fprintf(fil, "\t\tXml::XmlNode n(it, \"%s\");\n", el.Name().c_str());
00554                         fprintf(fil, "\t\twhile (n)\n");
00555                         fprintf(fil, "\t\t{\n");
00556                         if (el.IsComplexType())
00557                         {
00558                                 fprintf(fil, "\t\t\t%s tmp(n);\n", el.CType().c_str());
00559                                 fprintf(fil, "\t\t\t_element_%s.push_back( tmp );\n", el.CName().c_str());
00560                         }
00561                         else
00562                         if (el.BaseType() == "std::string")
00563                         {
00564                                 fprintf(fil, "\t\t\t_element_%s.push_back( n.GetContent() );\n", el.CName().c_str());
00565                         }
00566                         else
00567                         {
00568                                 fprintf(fil, "\t\t\t_element_%s.push_back( atoi(n.GetContent().c_str()) );\n", el.CName().c_str());
00569                         }
00570                         fprintf(fil, "\t\t\t++n;\n");
00571                         fprintf(fil, "\t\t}\n");
00572                         fprintf(fil, "\t}\n");
00573                 }
00574                 else
00575                 if (el.IsComplexType())
00576                 {
00577                         fprintf(fil, "\t{\n");
00578                         fprintf(fil, "\t\tXml::XmlNode n(it, \"%s\");\n", el.Name().c_str());
00579                         fprintf(fil, "\t\tif (n)\n");
00580                         fprintf(fil, "\t\t\t_element_%s.FromXml( n );\n", el.CName().c_str());
00581                         fprintf(fil, "\t}\n");
00582                 }
00583                 else
00584                 if (el.BaseType() == "std::string")
00585                 {
00586                         if (el.IsOptional())
00587                                 fprintf(fil, "\tif (it.Exists(\"%s\"))\n\t", el.Name().c_str());
00588                         fprintf(fil, "\tSet%s( it[\"%s\"] );\n", el.CName1up().c_str(), el.Name().c_str());
00589                 }
00590                 else
00591                 {
00592                         if (el.IsOptional())
00593                                 fprintf(fil, "\tif (it.Exists(\"%s\"))\n\t", el.Name().c_str());
00594                         fprintf(fil, "\tSet%s( atoi(std::string(it[\"%s\"]).c_str()) );\n", el.CName1up().c_str(), el.Name().c_str());
00595                 }
00596         }
00597         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00598         {
00599                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00600                 Attribute attr(m_wsdl, ref.second, "", NsHref());
00601 
00602                 if (attr.IsOptional())
00603                 {
00604                         fprintf(fil, "\tif (it.PropertyExists(\"%s\"))\n\t", attr.Name().c_str());
00605                 }
00606                 if (attr.BaseType() == "std::string")
00607                         fprintf(fil, "\tSet%s(it.GetProperty(\"%s\"));\n", attr.CName1up().c_str(), attr.Name().c_str());
00608                 else
00609                         fprintf(fil, "\tSet%s( atoi(it.GetProperty(\"%s\").c_str()) );\n", attr.CName1up().c_str(), attr.Name().c_str());
00610         }
00611         if (m_b_is_mixed)
00612         {
00613                 fprintf(fil, "\tm_mixed_content = it.GetContent();\n");
00614         }
00615 }

void ComplexType::to_string ( std::list< std::pair< std::string, Xml::XmlNode > > &  members,
std::list< std::pair< std::string, Xml::XmlNode > > &  attrs,
FILE *  fil 
) const [private]

Definition at line 618 of file ComplexType.cpp.

References Element::BaseType(), Attribute::BaseType(), Element::CName(), Attribute::CName1up(), TypeBase::CType(), Wsdl::GetApplication(), Element::IsComplexType(), Element::IsOptional(), Attribute::IsOptional(), Element::IsVector(), Application::ListType(), m_b_is_mixed, m_b_is_sequence, m_extends, m_extends_cls, TypeBase::m_wsdl, Element::Name(), Attribute::Name(), and TypeBase::NsHref().

Referenced by CreateImplementation().

00619 {
00620         fprintf(fil, "\tstd::string r;\n");
00621         if (attrs.empty())
00622         {
00623                 fprintf(fil, "\tif (!name.empty())\n\t");
00624                 fprintf(fil, "\tr += \"<\" + name + \">\";\n");
00625         }
00626         else
00627         {
00628                 fprintf(fil, "\tif (!name.empty())\n\t");
00629                 fprintf(fil, "\tr += \"<\" + name;\n");
00630 
00631                 for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = attrs.begin(); it != attrs.end(); it++)
00632                 {
00633                         const std::pair<std::string, Xml::XmlNode>& ref = *it;
00634                         Attribute attr(m_wsdl, ref.second, "", NsHref());
00635 
00636                         if (attr.IsOptional())
00637                         {
00638                                 fprintf(fil, "\tif (%sIsSet())\n\t", attr.CName1up().c_str());
00639                         }
00640                         if (attr.BaseType() == "std::string")
00641                                 fprintf(fil, "\tr += \" %s='\" + Get%s() + \"'\";\n", attr.Name().c_str(), attr.CName1up().c_str());
00642                         else
00643                         {
00644                                 fprintf(fil, "{\n");
00645                                 fprintf(fil, "\t\tr = r + \" %s='\" + Utility::l2string(Get%s()) + \"'\";\n", attr.Name().c_str(), attr.CName1up().c_str());
00646                                 fprintf(fil, "\t}\n");
00647                         }
00648                 }
00649                 fprintf(fil, "\tr += \">\";\n");
00650         }
00651         if (!m_extends.empty())
00652         {
00653                 fprintf(fil, "\tr += %s::ToString();\n", m_extends_cls.c_str());
00654         }
00655         for (std::list<std::pair<std::string, Xml::XmlNode> >::const_iterator it = members.begin(); it != members.end(); it++)
00656         {
00657                 const std::pair<std::string, Xml::XmlNode>& ref = *it;
00658                 Element el(m_wsdl, ref.second, m_b_is_sequence, false, "", NsHref());
00659                 if (el.IsVector())
00660                 {
00661                         fprintf(fil, "\tfor (%s<%s>::const_iterator it = _element_%s.begin(); it != _element_%s.end(); it++)\n",
00662                                 m_wsdl.GetApplication().ListType().c_str(),
00663                                 el.CType().c_str(), el.CName().c_str(), el.CName().c_str());
00664                         fprintf(fil, "\t{\n");
00665 
00666                         if (el.IsComplexType())
00667                         {
00668                                 fprintf(fil, "\t\tconst %s& ref = *it;\n", el.CType().c_str());
00669                                 fprintf(fil, "\t\tr += ref.ToString(\"%s\");\n", el.Name().c_str());
00670                         }
00671                         else
00672                         if (el.BaseType() == "std::string")
00673                         {
00674                                 fprintf(fil, "\t\tr += \"<%s>\" + *it + \"</%s>\";\n",
00675                                         el.Name().c_str(), el.Name().c_str());
00676                         }
00677                         else
00678                         {
00679                                 fprintf(fil, "\t\t{\n");
00680                                 fprintf(fil, "\t\t\tr = r + \"<%s>\" + Utility::l2string(*it) + \"</%s>\";\n",
00681                                         el.Name().c_str(), el.Name().c_str());
00682                                 fprintf(fil, "\t\t}\n");
00683                         }
00684 
00685                         fprintf(fil, "\t}\n");
00686                 }
00687                 else
00688                 if (el.IsComplexType())
00689                 {
00690                         fprintf(fil, "\tr += _element_%s.ToString(\"%s\");\n", el.CName().c_str(), el.Name().c_str());
00691                 }
00692                 else
00693                 if (el.BaseType() == "std::string")
00694                 {
00695                         if (el.IsOptional())
00696                                 fprintf(fil, "\tif (_element_%s_is_set)\n\t", el.CName().c_str());
00697                         fprintf(fil, "\tr += \"<%s>\" + _element_%s + \"</%s>\";\n",
00698                                 el.Name().c_str(), el.CName().c_str(), el.Name().c_str());
00699                 }
00700                 else
00701                 {
00702                         if (el.IsOptional())
00703                                 fprintf(fil, "\tif (_element_%s_is_set)\n", el.CName().c_str());
00704                         fprintf(fil, "\t{\n");
00705                         fprintf(fil, "\t\tr = r + \"<%s>\" + Utility::l2string(_element_%s) + \"</%s>\";\n",
00706                                 el.Name().c_str(), el.CName().c_str(), el.Name().c_str());
00707                         fprintf(fil, "\t}\n");
00708                 }
00709         }
00710         if (m_b_is_mixed)
00711         {
00712                 fprintf(fil, "\tr += m_mixed_content;\n");
00713         }
00714         fprintf(fil, "\tif (!name.empty())\n\t");
00715         fprintf(fil, "\tr += \"</\" + name + \">\";\n");
00716         fprintf(fil, "\treturn r;\n");
00717 }

Xml::XmlNode ComplexType::Start (  )  const [private]

Definition at line 873 of file ComplexType.cpp.

References TypeBase::m_node.

Referenced by ComplexType(), GetAttributes(), GetMembers(), GetRef(), and NumberOfMembers().

00874 {
00875         Xml::XmlNode complexContent(m_node, "complexContent");
00876         if (complexContent)
00877         {
00878                 Xml::XmlNode extension(complexContent, "extension");
00879                 if (extension)
00880                 {
00881                         if (extension.PropertyExists("base"))
00882                         {
00883                                 return extension;
00884                         }
00885                 }
00886         }
00887         return m_node;
00888 }

Member Data Documentation

std::string ComplexType::m_name [private]

Definition at line 72 of file ComplexType.h.

Referenced by CName(), from_xml(), IsGenerated(), Name(), and SetGenerated().

bool ComplexType::m_b_is_sequence [private]

Definition at line 73 of file ComplexType.h.

Referenced by ComplexType(), CreateImplementation(), CreateInterface(), from_xml(), GetMembers(), GetRef(), IsSequence(), NumberOfMembers(), OkToGenerate(), reset_members(), and to_string().

bool ComplexType::m_b_is_all [private]

Definition at line 74 of file ComplexType.h.

Referenced by ComplexType(), and IsAll().

bool ComplexType::m_b_complexContent [private]

Definition at line 75 of file ComplexType.h.

Referenced by ComplexType(), CreateInterface(), IsComplexContent(), and OkToGenerate().

bool ComplexType::m_b_is_array [private]

Definition at line 76 of file ComplexType.h.

Referenced by ComplexType(), CreateInterface(), IsArray(), and OkToGenerate().

bool ComplexType::m_b_is_mixed [private]

Definition at line 77 of file ComplexType.h.

Referenced by ComplexType(), CreateImplementation(), CreateInterface(), from_xml(), IsMixed(), and to_string().

std::string ComplexType::m_extends [private]

Definition at line 78 of file ComplexType.h.

Referenced by ComplexType(), CreateInterface(), from_xml(), reset_members(), and to_string().

std::string ComplexType::m_extends_cls [private]

Definition at line 79 of file ComplexType.h.

Referenced by ComplexType(), CreateInterface(), from_xml(), reset_members(), and to_string().

std::map< std::string, bool > ComplexType::m_b_generated [static, private]

Definition at line 80 of file ComplexType.h.

Referenced by IsGenerated(), SetGenerated(), and ShowGenerated().

The documentation for this class was generated from the following files:
Generated on Sun Oct 11 10:57:20 2009 for Xml Schema class generator by  doxygen 1.5.5