ServiceDeclaration.h

/*
 * Copyright (C) 2014 by Dr. Marc Boris Duerner
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef Pt_Soap_ServiceDeclaration_h
#define Pt_Soap_ServiceDeclaration_h

#include <Pt/Soap/Api.h>
#include <Pt/NonCopyable.h>
#include <Pt/String.h>
#include <Pt/Types.h>
#include <string>
#include <vector>
#include <map>

namespace Pt {

namespace Soap {

class Parameter;

class Type : private NonCopyable
{
    public:
        enum TypeId
        {
            Array = 1,
            Struct = 2,
            Bool = 3,
            Int = 4,
            Float = 5,
            String = 6,
            Base64 = 7,
            Dict = 8,
            DictElement = 9
        };
    
    public:
        explicit Type(TypeId typeId)
        : _typeId(typeId)
        {}

        virtual ~Type()
        {}

        TypeId typeId() const
        { return _typeId; }

        virtual bool isSimple() const = 0;

        virtual const Parameter* getParameter(std::size_t n) const = 0;

        virtual const Parameter* getParameter(const std::string& name) const = 0;
                
        virtual const char* name() const = 0;

        virtual std::size_t size() const = 0;

    private:
        TypeId _typeId;    
};


class SimpleType : public Type
{
    public:
        explicit SimpleType(TypeId typeId)
        : Type(typeId)
        {            
        }

        virtual ~SimpleType()
        {}

        virtual bool isSimple() const
        {
            return true;
        }

        virtual const Parameter* getParameter(std::size_t) const
        { return 0; }

        virtual const Parameter* getParameter(const std::string&) const
        { return 0; }

        std::size_t size() const
        {
            return 0;
        }
};


class ComplexType : public Type
{
    public:
        explicit ComplexType(TypeId typeId, const std::string& name)
        : Type(typeId)    
        , _name(name)    
        {            
        }

        virtual ~ComplexType()
        {}

        virtual bool isSimple() const
        {
            return false;
        }

        virtual const char* name() const
        {
            return _name.c_str();
        }

    private:    
        std::string _name;
};


class Parameter
{
    public:
        Parameter()
        : _type(0)
        , _min(1)
        , _max(1)
        {}
        
        Parameter(const std::string& name, const Type& t)
        : _name(name)
        , _type(&t)
        , _min(1)
        , _max(1)
        { }

        virtual ~Parameter()
        {}

        const Type* type() const
        { return _type; }

        const std::string& name() const
        { return _name; }

        void set(const std::string& name, const Type& t)
        {
            _name = name;
            _type = &t;
        }

        int minOccurs() const
        {
          return _min;
        }

        int maxOccurs() const
        {
          return _max;
        }

        void setOccurrence(int min, int max)
        {
          _min = min;
          _max= max;
        }

    private:
        std::string _name;
        const Type* _type;
        int _min;
        int _max;
};


class PT_SOAP_API BooleanType : public SimpleType
{
    public:
        BooleanType();

        virtual ~BooleanType();

        virtual const char* name() const
        {
            return "boolean";
        }
};


class PT_SOAP_API IntegerType : public SimpleType
{
    public:
        IntegerType();

        virtual ~IntegerType();  

        virtual const char* name() const
        {
            return "int";
        }
};


class PT_SOAP_API FloatType : public SimpleType
{
    public:
        FloatType();

        virtual ~FloatType();

        virtual const char* name() const
        {
            return "double";
        }
};


class PT_SOAP_API StringType : public SimpleType
{
    public:
        StringType();

        virtual ~StringType();

        virtual const char* name() const
        {
            return "string";
        }
};


class PT_SOAP_API Base64Type : public SimpleType
{
    public:
        Base64Type();

        virtual ~Base64Type();

        virtual const char* name() const
        {
            return "base64Binary";
        }
};


class PT_SOAP_API StructType : public ComplexType
{
    public:
        StructType(const std::string& name);

        virtual ~StructType();

        void addParameter(const std::string& name, const Type& param, 
                          int minOccurence = 1, int maxOccurence = 1);

        virtual const Parameter* getParameter(std::size_t n) const;

        virtual const Parameter* getParameter(const std::string& name) const;

        virtual std::size_t size() const
        {
            return _paramList.size();
        }

    private:
        typedef std::vector<Parameter> ParameterList;
        ParameterList _paramList;
};


class PT_SOAP_API ArrayType : public ComplexType
{
    public:
        ArrayType(const std::string& name);
        
        ArrayType(const std::string& name, const Type& elem, const std::string& elemName);

        virtual ~ArrayType();

        void setElement(const std::string& elemName, const Type& elem);

        virtual const Parameter* getParameter(std::size_t n) const;

        virtual const Parameter* getParameter(const std::string& name) const;

        virtual std::size_t size() const
        {
            return 1;
        }

    private:
        Parameter _elem;
};


class PT_SOAP_API DictElementType : public ComplexType
{
    public:
        DictElementType(const std::string& name);

        virtual ~DictElementType();

        void setKey(const std::string& name, const Type& param);

        void setValue(const std::string& name, const Type& param);

        virtual const Parameter* getParameter(std::size_t n) const;

        virtual const Parameter* getParameter(const std::string& name) const;

        virtual std::size_t size() const
        {
            return 0;
        }

    private:
        Parameter _key;
        Parameter _value;
};


class PT_SOAP_API DictType : public ComplexType
{
    public:
        DictType(const std::string& typeName, const std::string& elemTypeName);

        virtual ~DictType();

        void setElement(const std::string& elemName,
                        const std::string& keyname, const Type& keyType, 
                        const std::string& valueName, const Type& valueType);

        virtual const Parameter* getParameter(std::size_t n) const;

        virtual const Parameter* getParameter(const std::string& name) const;

        virtual std::size_t size() const
        {
            return 1;
        }

    private:
        DictElementType _elemType;
        Parameter       _elem;
};


PT_SOAP_API const BooleanType& boolType();


PT_SOAP_API const IntegerType& intType();


PT_SOAP_API const FloatType& floatType();


PT_SOAP_API const StringType& stringType();


PT_SOAP_API const Base64Type& base64Type();


class PT_SOAP_API Operation : private NonCopyable
{
    public:
        typedef std::vector<Parameter> ParameterList;

        Operation(const Pt::String& inputName, const Pt::String& outputName);

        virtual ~Operation();

        const Pt::String& inputName() const
        { return _inputName; }

        const Pt::String& outputName() const
        { return _outputName; }

        void addInput(const std::string& name, const Type& param);

        const Parameter* getInput(const std::string& name) const;

        const Parameter* getInput(std::size_t n) const;

        void setOutput(const std::string& name, const Type& param);

        const Parameter* getOutput() const;

        const ParameterList& parameters() const
        {
            return _params;
        }

    private:
        ParameterList _params;
        Parameter _out;
        Pt::String _inputName;
        Pt::String _outputName;
};


class PT_SOAP_API ServiceDeclaration 
{
    public:
        ServiceDeclaration(const std::string& name);

        virtual ~ServiceDeclaration();

        const std::string& name() const
        { return _name; }

        const std::string& targetNamespace() const
        { return _targetNamespace; }

        void setTargetNamespace(const std::string& ns)
        { _targetNamespace = ns; }

        void addOperation(Operation& op);

        const Operation* getOperation(const Pt::String& name) const;
        
        void toWsdl(std::ostream& os) const;

    public:
        // deprecated
        static const BooleanType& boolType();
        
        // deprecated
        static const IntegerType& intType();
        
        // deprecated
        static const FloatType& floatType();
        
        // deprecated
        static const StringType& stringType();

    private:
        static void createComplexTypeList(std::map<std::string,const Type*>& complexTypes, const Type* type);

    private:
        std::string _name;
        std::string _targetNamespace;
        typedef std::vector<Operation*> OperationList;
        OperationList _operations;
};



template <typename T>
class BasicParameter : public Type
{
    public:
        BasicParameter()
        { }
};


template <>
class BasicParameter<int> : public IntegerType
{
    public:
        BasicParameter()
        { }
};


template <typename T>
class BasicParameter< std::vector<T> > : public ArrayType
{
    public:
        BasicParameter()
        { 
            setElement(_elem);
        }

    private:
        BasicParameter<T> _elem;
};


template <typename R, typename A1, typename A2>
class BasicProcedureDefinition : public Operation
{
    public:
        BasicProcedureDefinition()
        {}

    private:
        BasicParameter<R> _rDef;
        BasicParameter<A1> _a1Def;
        BasicParameter<A2> _a2Def;
};

} // namespace Soap

} // namespace Pt

#endif // Pt_Soap_ServiceDefinition_h