wsdl2cpp.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 <stdio.h>
#include <Sockets/XmlDocument.h>
#include <iostream>
#include <Sockets/Exception.h>
#include "Wsdl.h"
#include "WsdlException.h"
#include "Types.h"
#include "Application.h"
#include "ComplexType.h"


void view_wsdl(Application& appl, Wsdl& wsdl)
{
        std::string target_ns = wsdl.GetTargetNamespace();
        std::string prefix_ns = wsdl.GetTargetNamespacePrefix();
        printf("Target Namespace: %s\n", target_ns.c_str());
        printf("Target Ns Prefix: %s\n", prefix_ns.c_str());

        std::list<std::string> ops = wsdl.GetOperations( appl.Portname() );
        printf("Number of operations: %d\n", ops.size());

        for (std::list<std::string>::iterator it = ops.begin(); it != ops.end(); it++)
        {
                std::string op = *it;
                printf("%s\n----------------------------------------\n", op.c_str());
                printf("SOAPaction: %s\n", wsdl.GetSoapAction(appl.Portname(), op).c_str());
                std::string in;
                std::string out;
                std::string fault;
                std::string path;
                try {
                        in = wsdl.GetMessage(appl.Portname(), op, "input");
                } catch (const WsdlException&) {}
                try {
                        out = wsdl.GetMessage(appl.Portname(), op, "output");
                } catch (const WsdlException&) {}
                try {
                        fault = wsdl.GetMessage(appl.Portname(), op, "fault");
                } catch (const WsdlException&) {}
                if (!in.empty())
                {
                        printf("Input: %s\n", in.c_str());
                        wsdl.ShowMessage(in);
                }
                if (!out.empty())
                {
                        printf("Output: %s\n", out.c_str());
                        wsdl.ShowMessage(out);
                }
                if (!fault.empty())
                {
                        printf("Fault: %s\n", fault.c_str());
                        wsdl.ShowMessage(fault);
                }
                //
                printf("\n");
        }
}


int main(int argc, char *argv[])
{
        Application appl(argc, argv); // parse command line

        try
        {
                Xml::XmlDocument zz(appl.Filename()); //"http://schemas.xmlsoap.org/wsdl/http/", "definitions");
                Wsdl wsdl(appl, zz);

                // select port
                std::list<std::string> ports = wsdl.GetPorts();
                if (ports.size() > 1)
                {
                        bool ok = false;
                        for (std::list<std::string>::iterator it = ports.begin(); it != ports.end(); it++)
                                if (appl.Portname() == *it)
                                        ok = true;
                        if (!ok)
                        {
                                if (!appl.Portname().empty())
                                        printf("Port name not found: \"%s\"\n", appl.Portname().c_str());
                                printf("Select one of these ports:\n");
                                for (std::list<std::string>::iterator it = ports.begin(); it != ports.end(); it++)
                                        printf("  %s\n", it -> c_str());
                                return -1;
                        }
                }

                // generate types
                wsdl.CreateInterface();
                wsdl.CreateImplementation();

                {
                        view_wsdl(appl, wsdl);
                        return 0;
                }

                // operations...
                Types t(appl, wsdl);
                t.generate();

        }
        catch (const Exception& e)
        {
                std::cout << "---------------------------------------------" << std::endl;
                std::cout << e.ToString() << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                std::cout << e.Stack() << std::endl;
        }

        ComplexType::ShowGenerated();
        return 0;
}

---