//  Example stubs for TemperatureConverter operations.  This function is not intended 

//  to be called, but rather as a source for copy-and-paste development.



function stubs()

{

    // f2cConvertion operation

    try {

        /* double */ f2cConvertionReturn = TemperatureConverter.f2cConvertion(/* double */ param_fValue);

    } catch (e) {

        // fault handling

    }



    // c2fConvertion operation

    try {

        /* double */ c2fConvertionReturn = TemperatureConverter.c2fConvertion(/* double */ param_cValue);

    } catch (e) {

        // fault handling

    }



}

stubs.visible = false;



var TemperatureConverter = new WebService("TemperatureConverterSOAP12port_http");



TemperatureConverter.f2cConvertion =

    function f2cConvertion(/* double */ _fValue)

    {

        var isAsync, request, response, resultValue;

        

        this._options = new Array();

        isAsync = (this.f2cConvertion.callback != null && typeof(this.f2cConvertion.callback) == 'function');

        request = 

            '<p:f2cConvertion xmlns:p="http://example.ws">' +

                (_fValue == null ? '' : '<fValue xmlns="http://example.ws">' + this._encodeXML(_fValue) + '</fValue>') +

            '</p:f2cConvertion>' ;

        

        if (isAsync) {

            try {

                this._call(

                    "f2cConvertion",

                    request,

                    function(thisRequest, callbacks) {

                        if (thisRequest.error != null) {

                            callbacks[1](thisRequest.error);

                        } else {

                            response = new XML(thisRequest.responseText);

                            if (response == null) {

                                resultValue = null;

                            } else {

                            

                           var extractedValue = (response["return"]).toString();

                                resultValue;

                                if (extractedValue == "INF" || extractedValue == "+INF")

                                    resultValue = Infinity;

                                else if (extractedValue == "-INF")

                                    resultValue = -Infinity;

                                else resultValue = /* double */ parseFloat(extractedValue);

                            }

                            callbacks[0](resultValue);

                        }

                    },

                    new Array(this.f2cConvertion.callback, this.f2cConvertion.onError)

                );

            } catch (e) {

                var error;

                if (WebServiceError.prototype.isPrototypeOf(e)) {

                    error = e;

                } else if (typeof(e) == "string") {

                    error = new WebServiceError(e, "Internal Error");

                } else {

                    error = new WebServiceError(e.description, e.number, e.number);

                }

                this.f2cConvertion.onError(error);

            }

        } else {

            try {

                                response = this._call("f2cConvertion", request);

                            

                           var extractedValue = (response["return"]).toString();

                                resultValue;

                                if (extractedValue == "INF" || extractedValue == "+INF")

                                    resultValue = Infinity;

                                else if (extractedValue == "-INF")

                                    resultValue = -Infinity;

                                else resultValue = /* double */ parseFloat(extractedValue);

                                return resultValue;

            } catch (e) {

                if (typeof(e) == "string") throw(e);

                if (e.message) throw(e.message);

                throw (e.reason + e.detail);

            }

        }

        return null; // Suppress warnings when there is no return.

    }

TemperatureConverter.f2cConvertion.callback = null;



TemperatureConverter.c2fConvertion =

    function c2fConvertion(/* double */ _cValue)

    {

        var isAsync, request, response, resultValue;

        

        this._options = new Array();

        isAsync = (this.c2fConvertion.callback != null && typeof(this.c2fConvertion.callback) == 'function');

        request = 

            '<p:c2fConvertion xmlns:p="http://example.ws">' +

                (_cValue == null ? '' : '<cValue xmlns="http://example.ws">' + this._encodeXML(_cValue) + '</cValue>') +

            '</p:c2fConvertion>' ;

        

        if (isAsync) {

            try {

                this._call(

                    "c2fConvertion",

                    request,

                    function(thisRequest, callbacks) {

                        if (thisRequest.error != null) {

                            callbacks[1](thisRequest.error);

                        } else {

                            response = new XML(thisRequest.responseText);

                            if (response == null) {

                                resultValue = null;

                            } else {

                            

                           var extractedValue = (response["return"]).toString();

                                resultValue;

                                if (extractedValue == "INF" || extractedValue == "+INF")

                                    resultValue = Infinity;

                                else if (extractedValue == "-INF")

                                    resultValue = -Infinity;

                                else resultValue = /* double */ parseFloat(extractedValue);

                            }

                            callbacks[0](resultValue);

                        }

                    },

                    new Array(this.c2fConvertion.callback, this.c2fConvertion.onError)

                );

            } catch (e) {

                var error;

                if (WebServiceError.prototype.isPrototypeOf(e)) {

                    error = e;

                } else if (typeof(e) == "string") {

                    error = new WebServiceError(e, "Internal Error");

                } else {

                    error = new WebServiceError(e.description, e.number, e.number);

                }

                this.c2fConvertion.onError(error);

            }

        } else {

            try {

                                response = this._call("c2fConvertion", request);

                            

                           var extractedValue = (response["return"]).toString();

                                resultValue;

                                if (extractedValue == "INF" || extractedValue == "+INF")

                                    resultValue = Infinity;

                                else if (extractedValue == "-INF")

                                    resultValue = -Infinity;

                                else resultValue = /* double */ parseFloat(extractedValue);

                                return resultValue;

            } catch (e) {

                if (typeof(e) == "string") throw(e);

                if (e.message) throw(e.message);

                throw (e.reason + e.detail);

            }

        }

        return null; // Suppress warnings when there is no return.

    }

TemperatureConverter.c2fConvertion.callback = null;







// WebService object.

function WebService(endpointName)

{

    this.readyState = 0;

    this.onreadystatechange = null;

    

    //public accessors for manually intervening in setting the address (e.g. supporting tcpmon)

    this.getAddress = function (endpointName)

    {

        return this._endpointDetails[endpointName].address;

    }

    

    this.setAddress = function (endpointName, address)

    {

        this._endpointDetails[endpointName].address = address;

    }



    // private helper functions

    this._getWSRequest = function()

    {

        var wsrequest;

        try {

            wsrequest = new WSRequest();

        } catch(e) {

            try {

                wsrequest = new ActiveXObject("WSRequest");

            } catch(e) {

                try {

                    wsrequest = new SOAPHttpRequest();

                    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");

                } catch (e) {

                    throw new WebServiceError("WSRequest object not defined.", "WebService._getWSRequest() cannot instantiate WSRequest object.");

                }

            }

        }

        return wsrequest;

    }

        

    this._endpointDetails = 

        {

            "TemperatureConverterSOAP12port_http": {

                "type" : "SOAP12",

                "address" : "TemperatureConverter",

                "action" : {

                    "f2cConvertion" : "urn:f2cConvertion",

                    "c2fConvertion" : "urn:c2fConvertion"

                },

                "soapaction" : {

                    "f2cConvertion" : "urn:f2cConvertion",

                    "c2fConvertion" : "urn:c2fConvertion"

                }

            },

            "TemperatureConverterSOAP11port_http": {

                "type" : "SOAP11",

                "address" : "TemperatureConverter",

                "action" : {

                    "f2cConvertion" : "urn:f2cConvertion",

                    "c2fConvertion" : "urn:c2fConvertion"

                },

                "soapaction" : {

                    "f2cConvertion" : "urn:f2cConvertion",

                    "c2fConvertion" : "urn:c2fConvertion"

                }

            },

            "TemperatureConverterHttpport": {

                "type" : "HTTP",

                "address" : "TemperatureConverter",

                "httplocation" : {

                    "f2cConvertion" : "TemperatureConverter/f2cConvertion",

                    "c2fConvertion" : "TemperatureConverter/c2fConvertion"

                },

                "httpmethod" : {

                        "f2cConvertion" : "POST",

                        "c2fConvertion" : "POST"

                },

                "httpinputSerialization" : {

                        "f2cConvertion" : "application/x-www-form-urlencoded",

                        "c2fConvertion" : "application/x-www-form-urlencoded"

                }

            }

    };

    this.endpoint = endpointName;



    this._encodeXML = function (value) {

        var re;

        var str = value.toString();

        re = /&/g;

        str = str.replace(re, "&amp;");

        re = /</g;

        str = str.replace(re, "&lt;");

       return(str);

    };



    this._call = function (opName, reqContent, callback, userdata)

    {

        var details = this._endpointDetails[this.endpoint];

        if (details.type == 'SOAP12') this._options.useSOAP = 1.2;

        else if (details.type == 'SOAP11') this._options.useSOAP = 1.1;

        else if (details.type == 'HTTP') this._options.useSOAP = false;



        if (details.action != null) {

            this._options.useWSA = true;

            this._options.action = details.action[opName];

        } else if (details.soapaction != null) {

            this._options.useWSA = false;

            this._options.action = details.soapaction[opName];

        } else {

            this._options.useWSA = false;

            this._options.action = undefined;

        }

        

        if (details["httpmethod"] != null) {

            this._options.HTTPMethod = details.httpmethod[opName];

        } else {

            this._options.HTTPMethod = null;

        }

        

        if (details["httpinputSerialization"] != null) {

            this._options.HTTPInputSerialization = details.httpinputSerialization[opName];

        } else {

            this._options.HTTPInputSerialization= null;

        }

        

        if (details["httplocation"] != null) {

            this._options.HTTPLocation = details.httplocation[opName];

        } else {

            this._options.HTTPLocation = null;

        }

        

        if (details["httpignoreUncited"] != null) {

            this._options.HTTPLocationIgnoreUncited = details.httpignoreUncited[opName];

        } else {

            this._options.HTTPLocationIgnoreUncited = null;

        }



        if (details["httpqueryParameterSeparator"] != null) {

            this._options.HTTPQueryParameterSeparator = details.httpqueryParameterSeparator[opName];

        } else {

            this._options.HTTPQueryParameterSeparator = null;

        }

        

        var isAsync = (typeof(callback) == 'function');

        

        var thisRequest = this._getWSRequest();

        if (isAsync) {

            thisRequest._userdata = userdata;

            thisRequest.onreadystatechange = 

                function() {

                    if (thisRequest.readyState == 4) {

                        callback(thisRequest, userdata);

                    }

                }

        }

        thisRequest.open(this._options, details.address, isAsync);

        thisRequest.send(reqContent);

        if (isAsync) {

            return "";

        } else {

            try {

                var resultContent = thisRequest.responseText;

                if (resultContent == "") { 

                    throw new WebServiceError("No response", "WebService._call() did not recieve a response to a synchronous request.");

                }

                var resultXML = new XML(thisRequest.responseText);

            } catch (e) {

                throw new WebServiceError(e);

            }

            return resultXML;

        }

    }				

}

WebService.visible = false;



// library function for dynamically converting an element with js:type annotation to a Javascript type.

convertJSType.visible = false;

function convertJSType(element, isWrapped) {

    if (element == null) return "";

    var extractedValue = element.*.toString();

    var resultValue, i;

    var js = new Namespace("http://www.wso2.org/ns/jstype");

    var type = element.@js::type;

    if (type == null) {

        type = "xml";

    } else {

        type = type.toString();

    }

    switch (type) {

        case "string":

            return extractedValue;

            break;

        case "number":

            return parseFloat(extractedValue);

            break;

        case "boolean":

            return extractedValue == "true" || extractedValue == "1";

            break;

        case "date":

            return xs_dateTime_to_date(extractedValue);

            break;

        case "array":

            resultValue = new Array();

            for (i=0; i<element.*.length(); i++) {

                resultValue = resultValue.concat(convertJSType(element[i]));

            }

            return(resultValue);

            break;

        case "object":

            resultValue = new Object();

            for (i=0; i<element.*.length(); i++) {

                resultValue[element[i].name()] = convertJSType(element[i]);

            }

            return(resultValue);

            break;

        case "xmllist":

            return element.*;

            break;

        case "xml":

        default:

            if (isWrapped == true)

                return element.*;

            else return element;

            break;

    }

}



// library function for parsing xs:date, xs:time, and xs:dateTime types into Date objects.

function xs_dateTime_to_date(dateTime)

{

    var buffer = dateTime;

    var p = 0; // pointer to current parse location in buffer.



    var era, year, month, day, hour, minute, second, millisecond;

    

    // parse date, if there is one.

    if (buffer.substr(p,1) == '-')

    {

        era = -1;

        p++;

    } else {

        era = 1;

    }

    

    if (buffer.charAt(p+2) != ':')

    {

        year = era * buffer.substr(p,4);

        p += 5;

        month = buffer.substr(p,2);

        p += 3;

        day = buffer.substr(p,2);

        p += 3;

    } else {

        year = 1970;

        month = 1;

        day = 1;

    }

    

    // parse time, if there is one

    if (buffer.charAt(p) != '+' && buffer.charAt(p) != '-')

    {

        hour = buffer.substr(p,2);

        p += 3;

        minute = buffer.substr(p,2);

        p += 3;

        second = buffer.substr(p,2);

        p += 2;

        if (buffer.charAt(p) == '.')

        {

            millisecond = parseFloat(buffer.substr(p))*1000;

            // Note that JS fractional seconds are significant to 3 places - xs:time is significant to more - 

            // though implementations are only required to carry 3 places.

            p++;

            while (buffer.charCodeAt(p) >= 48 && buffer.charCodeAt(p) <= 57) p++;

        } else {

            millisecond = 0;

        }

    } else {

        hour = 0;

        minute = 0;

        second = 0;

        millisecond = 0;

    }

    

    var tzhour = 0;

    var tzminute = 0;

    // parse time zone

    if (buffer.charAt(p) != 'Z' && buffer.charAt(p) != '') {

        var sign = (buffer.charAt(p) == '-' ? -1 : +1);

        p++;

        tzhour = sign * buffer.substr(p,2);

        p += 3;

        tzminute = sign * buffer.substr(p,2);

    }

    

    var thisDate = new Date();

    thisDate.setUTCFullYear(year);

    thisDate.setUTCMonth(month-1);

    thisDate.setUTCDate(day);

    thisDate.setUTCHours(hour);

    thisDate.setUTCMinutes(minute);

    thisDate.setUTCSeconds(second);

    thisDate.setUTCMilliseconds(millisecond);    

    thisDate.setUTCHours(thisDate.getUTCHours() - tzhour);

    thisDate.setUTCMinutes(thisDate.getUTCMinutes() - tzminute);

    return thisDate;

}

xs_dateTime_to_date.visible = false;



function scheme(url) {

    var s = url.substring(0, url.indexOf(':'));

    return s;

}

scheme.visible = false;



function domain(url) {

    var d = url.substring(url.indexOf('://') + 3, url.indexOf('/',url.indexOf('://')+3));

    return d;

}

domain.visible = false;



function domainNoPort(url) {

    var d = domain(url);

    if (d.indexOf(":") >= 0)

    d = d.substring(0, d.indexOf(':'));

    return d;

}

domainNoPort.visible = false;



try {

    var secureEndpoint = "";

    var pageUrl = document.URL;

    var pageScheme = scheme(pageUrl);

    // only attempt fixup if we're from an http/https domain ('file:' works fine on IE without fixup)

    if (pageScheme == "http" || pageScheme == "https") {

        var pageDomain = domain(pageUrl);

        var pageDomainNoPort = domainNoPort(pageUrl);

        var endpoints = TemperatureConverter._endpointDetails;

        // loop through each available endpoint

        for (var i in endpoints) {

            var address = endpoints[i].address;

            // if we're in a secure domain, set the endpoint to the first secure endpoint we come across

            if (secureEndpoint == "" && pageScheme == "https" && scheme(address) == "https") {

                secureEndpoint = i;

                TemperatureConverter.endpoint=secureEndpoint;

            }

            // if we're in a known localhost domain, rewrite the endpoint domain so that we won't get

            //  a bogus xss violation

            if (pageDomainNoPort.indexOf('localhost') == 0 || pageDomainNoPort.indexOf('127.0.0.1') == 0 ) {

                    endpoints[i].address = address.replace(domainNoPort(address), pageDomainNoPort);

            }

        }

    }

} catch (e) { }