Element.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 "Element.h"
#include <Sockets/XmlNode.h>
#include "WsdlException.h"
#include "Wsdl.h"
#include "Split.h"
#include "SimpleType.h"
#include <iostream>
#include "Application.h"


Element::Element(const Wsdl& wsdl, const Xml::XmlNode& node, bool in_sequence, bool in_choice, const std::string& name, const std::string& ns_prefix)
: TypeBase(wsdl, node, ns_prefix, "")
, m_appl(wsdl.GetApplication())
, m_name(!name.empty() ? name : node.PropertyExists("name") ? node.GetProperty("name") : "")
, m_minOccurs(node.PropertyExists("minOccurs") ? atoi(node.GetProperty("minOccurs").c_str()) : 1)
, m_maxOccurs(1)
{
        if (node.PropertyExists("type"))
        {
                std::string type = node.GetProperty("type");
                SetType(type);
        }
        else
        if (node.PropertyExists("ref"))
        {
                m_name = node.GetProperty("ref");
                Xml::XmlNode n = wsdl.GetElement( m_name );
                if (n)
                {
                        if (n.PropertyExists("type"))
                        {
                                std::string type = n.GetProperty("type");
                                SetType(type);
                        }
                }
        }
        else
        {
                Xml::XmlNode n(node, "complexType");
                if (n)
                {
                        std::string prefix = node.GetNsMapRe()[ns_prefix];
                        std::string type = prefix + ":" + m_name + "_t";
                        SetType(type);
                }
        }
        if (node.PropertyExists("maxOccurs"))
        {
                std::string max = node.GetProperty("maxOccurs");
                if (max == "unbounded")
                {
                        if (!in_sequence)
                                throw WsdlException("Using 'unbounded' on maxOccurs outside sequence");
                        m_maxOccurs = -1;
                }
                else
                        m_maxOccurs = atoi(max.c_str());
        }
        //
        std::string t = TypeBase::CType();
        if (IsSimpleType())
        {
                Xml::XmlNode n = m_wsdl.FindSimpleType(m_ns_href, m_type);
                SimpleType sim(m_wsdl, n, Split(m_type).Type, Split(m_type).NS);
                t = sim.CType(); //TypeBase::CType(sim.Type());
        }
        m_base_type = t;
}


Element::~Element()
{
}


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


void Element::CreateInterface(FILE *fil) const
{
}


const std::string Element::CType_decl() const
{
        std::string t = TypeBase::CType();
        if (IsSimpleType())
        {
                Xml::XmlNode n = m_wsdl.FindSimpleType(m_ns_href, m_type);
                SimpleType sim(m_wsdl, n, Split(m_type).Type, Split(m_type).NS);
                t = sim.CType(); //TypeBase::CType(sim.Type());
        }
        if (IsVector())
        {
                t = m_appl.ListType() + "<" + t + ">";
        }
        return t;
}


const std::string Element::CType_in() const
{
        std::string t = TypeBase::CType();
        if (IsSimpleType())
        {
                Xml::XmlNode n = m_wsdl.FindSimpleType(m_ns_href, m_type);
                SimpleType sim(m_wsdl, n, Split(m_type).Type, Split(m_type).NS);
                t = sim.CType(); //TypeBase::CType(sim.Type());
        }
        if (IsBuiltin() || IsSimpleType())
        {
                if (t == "std::string")
                {
                        if (!IsVector())
                                t = "const " + t + "&";
                }
        }
        else
        {
                if (!IsVector())
                        t = "const " + t + "&";
        }
        if (IsVector())
        {
                t = "const " + m_appl.ListType() + "<" + t + ">&";
        }
        return t;
}


const std::string Element::CType_out() const
{
        std::string t = TypeBase::CType();
        if (IsSimpleType())
        {
                Xml::XmlNode n = m_wsdl.FindSimpleType(m_ns_href, m_type);
                SimpleType sim(m_wsdl, n, Split(m_type).Type, Split(m_type).NS);
                t = sim.CType(); //TypeBase::CType(sim.Type());
        }
        if (IsBuiltin() || IsSimpleType())
        {
                if (t == "std::string")
                {
                        if (!IsVector())
                                t = "const " + t + "&";
                }
        }
        else
        {
                if (!IsVector())
                        t = t + "&";
        }
        if (IsVector())
        {
                t = m_appl.ListType() + "<" + t + ">&";
        }
        return t;
}


const std::string Element::CName() const
{
        return Split(m_name).CName;
}


const std::string Element::CName1up() const
{
        return Split(m_name).CName1up;
}


const std::string Element::DefaultValue() const
{
        if (IsBuiltin())
        {
                std::string t = Split(m_type).CName;
                if (t == "string" || t == "date" || t == "dateTime")
                {
                }
                else
                        return "0";
        }
        return "";
}


bool Element::IsComplexType() const
{
        if (IsBuiltin())
                return false;
        try
        {
                Xml::XmlNode n = m_wsdl.FindComplexType(m_ns_href, m_type);
                return true;
        }
        catch (const Exception& e)
        {
        }
        return false;
}


bool Element::IsSimpleType() const
{
        if (IsBuiltin())
                return false;
        try
        {
                Xml::XmlNode n = m_wsdl.FindSimpleType(m_ns_href, m_type);
                return true;
        }
        catch (const Exception& e)
        {
        }
        return false;
}

---