TypeBase.cpp

Go to the documentation of this file.

/*
Copyright (C) 2008-2009  Anders Hedstrom

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include "TypeBase.h"
#include "Wsdl.h"
#include <Sockets/XmlNode.h>
#include "Split.h"
#include "WsdlException.h"

#define DEB(x) 


TypeBase::TypeBase(const Wsdl& wsdl, const Xml::XmlNode& node, const std::string& ns_prefix, const std::string& type) : m_wsdl(wsdl)
, m_node(node)
, m_ns_href( ns_prefix )
, m_type(type)
, m_b_is_numeric(false)
{
        if (!type.empty())
        {
                SetType( type );
        }
}


TypeBase::~TypeBase()
{
}


const std::string TypeBase::Documentation(const Xml::XmlNode& node) const
{
        Xml::XmlNode n(node, "annotation");
        if (n)
        {
                Xml::XmlNode n2(n, "documentation");
                if (n2)
                {
                        return n2.GetContent();
                }
        }
        return "";
}


const std::string TypeBase::CType() const
{
        std::string t;
        if (IsBuiltin())
        {
                t = Split(m_type).CName;
                if (t == "string" || t == "date" || t == "dateTime" ||
                    t == "anySimpleType" || t == "anyURI" ||
                    t == "time"
                )
                {
                        t = "std::string";
                }
                if (t == "boolean")
                        t = "bool";
                if (t == "byte")
                        t = "char";
                if (t == "decimal")
                        t = "double";
                if (t == "integer")
                        t = "int";
                if (t == "unsignedByte")
                        t = "unsigned char";
                if (t == "unsignedInt")
                        t = "unsigned int";
                if (t == "unsignedShort")
                        t = "unsigned short";
        }
        else
        {
                std::string parent = m_wsdl.GetParent(m_ns_href, m_type);
                std::string tmp;
                while (!parent.empty())
                {
                        tmp = Split(parent).CName1up + "::" + tmp;
                        parent = m_wsdl.GetParent(m_ns_href, parent);
                }
                if (m_wsdl.GetNamespace(m_ns_href).empty())
                        t = tmp + Split(m_type).CName1up;
                else
                        t = m_wsdl.GetNamespace(m_ns_href) + "::" + tmp + Split(m_type).CName1up;
        }
        return t;
}


void TypeBase::SetType(const std::string& x)
{
        std::string href = m_node.GetNsMap()[Split(x).NS];
        if (Split(x).NS.empty())
        {
                href = m_wsdl.GetTargetNamespace();
                Xml::XmlNode n(m_node);
                std::string alt = n.FindProperty("targetNamespace", true);
                if (!alt.empty() && alt != href)
                {
                        href = alt;
                }
        }
        if (href.empty())
        {
                std::map<std::string, std::string> mmap = m_node.GetNsMap();
DEB(            for (std::map<std::string, std::string>::iterator it = mmap.begin(); it != mmap.end(); it++)
                {
                        printf("prefix '%s'  namespace '%s'\n", it -> first.c_str(), it -> second.c_str());
                })
                throw WsdlException("Empty href, type = \"" + x + "\"");
        }
        m_ns_href = href;
        m_type = Split(x).Type;
        std::string ctype = CType();
        if (ctype.find("int") != std::string::npos ||
            ctype.find("short") != std::string::npos ||
            ctype.find("double") != std::string::npos)
        {
                m_b_is_numeric = true;
        }
}


bool TypeBase::IsBuiltin() const
{
        return m_ns_href == "http://www.w3.org/2001/XMLSchema";
}

---