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


Attribute::Attribute(const Wsdl& wsdl, const Xml::XmlNode& node, const std::string& name, const std::string& ns_prefix)
: TypeBase(wsdl, node, ns_prefix, Split(name).Type)
, m_name(!name.empty() ? name : node.PropertyExists("name") ? node.GetProperty("name") : "")
, m_b_default_is_set(false)
, m_b_fixed_is_set(false)
{
        if (node.PropertyExists("type"))
        {
                std::string type = node.GetProperty("type");
                SetType(type);
        }
        else
        {
                Xml::XmlNode n(node, "simpleType");
                if (n)
                {
                        std::string type = ns_prefix + "::" + Split(m_name).Type + "_t";
                        SetType(type);
                }
        }
        if (node.PropertyExists("use"))
                m_use = node.GetProperty("use");
        if (node.PropertyExists("default"))
        {
                m_default = node.GetProperty("default");
                m_b_default_is_set = true;
        }
        if (node.PropertyExists("fixed"))
        {
                m_fixed = node.GetProperty("fixed");
                m_b_fixed_is_set = true;
        }
        //
        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;
}


Attribute::~Attribute()
{
}


const std::string Attribute::Documentation() const
{
        return TypeBase::Documentation(m_node);
}


const std::string Attribute::CType() const
{
        return TypeBase::CType();
}


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


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


bool Attribute::IsOptional() const
{
        return m_use != "required";
}


const std::string Attribute::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());
        }
        return t;
}


const std::string Attribute::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")
                {
                        t = "const " + t + "&";
                }
        }
        else
        {
                t = "const " + t + "&";
        }
        return t;
}


const std::string Attribute::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")
                {
                        t = "const " + t + "&";
                }
        }
        else
        {
                t = t + "&";
        }
        return t;
}


const std::string Attribute::DefaultValue() const
{
        if (IsNumeric())
                return "0";
        if (CType() == "bool")
                return "false";
        return "";
}


bool Attribute::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;
}

---