Exemple #1
0
        /// <summary>
        /// Renders request XML for sending to storage.
        /// </summary>
        /// <param name="request">Request instance to render.</param>
        /// <returns>XML request as string.</returns>
        private string renderRequest(CPS_Request request)
        {
            Dictionary<string, string> envelopeFields = new Dictionary<string, string>();
            envelopeFields["storage"] = this.p_storageName;
            envelopeFields["user"] = this.p_username;
            envelopeFields["password"] = this.p_password;
            envelopeFields["command"] = request.getCommand();
            foreach (KeyValuePair<string, string> cep in this.p_customEnvelopeParams)
                envelopeFields[cep.Key] = cep.Value;

            if (request.getRequestId().Length > 0)
                envelopeFields["requestid"] = request.getRequestId();
            if (this.p_applicationId.Length > 0)
                envelopeFields["application"] = this.p_applicationId;
            if (request.getRequestType().Length > 0)
                envelopeFields["type"] = request.getRequestType();
            if (request.getClusterLabel().Length > 0)
                envelopeFields["label"] = request.getClusterLabel();

            return request.getRequestXML(this.p_documentRootXpath, this.p_documentIdXpath, envelopeFields, this.p_docid_resetting);
        }
Exemple #2
0
 /// <summary>
 /// Creates new empty instance of CPS Response class without parsing response XML.
 /// </summary>
 /// <param name="connection">CPS_Connection class instance.</param>
 /// <param name="request">CPS_Request class instance.</param>
 protected CPS_Response(CPS_Connection connection, CPS_Request request)
 {
     this.p_connection = connection;
     this.p_transactionId = null;
     this.p_simpleXml = null;
     this.p_errors = new List<CPS_SimpleXML>();
     this.p_textParams = new Dictionary<string, string>();
     this.p_contentArray = null;
     this.p_documents = new Dictionary<string, XmlElement>();
     this.p_facets = new Dictionary<string, Dictionary<string, int>>();
     this.p_words = null;
     this.p_wordCounts = new Dictionary<string, int>();
     this.p_aggregate = new Dictionary<string, List<XmlElement>>();
 }
Exemple #3
0
        /// <summary>
        /// Sends request to Clusterpoint Server. Returned CPS_Response should be casted to command-specific response class.
        /// </summary>
        /// <param name="request">Request to send.</param>
        /// <returns>Command-specific CPS_Response object instance.</returns>
        public CPS_Response sendRequest(CPS_Request request)
        {
            bool firstSend = true;
            string previousRenderedStorage = "";
            string requestXml = "";
            byte[] requestBytes = null;
            string rawResponse = "";
            bool quit = true;

            if (this.p_connectionSwitcher != null)
                this.p_connectionSwitcher.newRequest(request);

            do
            {
                CPS_Exception e = null;

                if (this.p_connectionSwitcher != null)
                    this.p_connectionString = this.parseConnectionString(this.p_connectionSwitcher.getConnectionString(ref this.p_storageName));

                try
                {
                    if (this.p_transactionId != null)
                        request.setParam("transaction_id", this.p_transactionId);
                    if (firstSend || previousRenderedStorage != this.p_storageName)
                    {
                        requestXml = this.renderRequest(request);
                        requestBytes = Encoding.UTF8.GetBytes(requestXml);
                        previousRenderedStorage = this.p_storageName;

                        if (this.p_debug)
                        {
                            FileStream fs = new FileStream("request.xml", FileMode.Create);
                            fs.Write(requestBytes, 0, requestBytes.Length);
                            fs.Close();
                        }
                    }
                    firstSend = false;

                    this.p_lastRequestSize = requestXml.Length;
                    this.p_lastNetworkDuration = 0;

                    Stopwatch totTimer = new Stopwatch();
                    Stopwatch netTimer = new Stopwatch();

                    totTimer.Start();
                    if (this.p_connectionString.Scheme.ToLower() == "http")
                    {
                        // TODO: implement HMAC support when server side supports it
                        HttpWebRequest webreq = (HttpWebRequest)HttpWebRequest.Create(this.p_connectionString.OriginalString);
                        webreq.UserAgent = this.p_applicationId;
                        webreq.Method = "POST";
                        webreq.ContentType = "application/x-www-form-urlencoded";
                        webreq.ContentLength = requestBytes.Length;
                        webreq.Headers["Recipient"] = this.p_storageName;
                        webreq.Proxy = null;

                        Stream webreq_data;
                        try
                        {
                            webreq_data = webreq.GetRequestStream();
                        }
                        catch (Exception)
                        {
                            throw new CPS_Exception("Invalid connection string").SetCode(CPS_Exception.ERROR_CODE.INVALID_CONNECTION_STRING);
                        }

                        netTimer.Start();
                        webreq_data.Write(requestBytes, 0, requestBytes.Length);
                        webreq_data.Close();
                        netTimer.Stop();

                        HttpWebResponse webrsp;
                        try
                        {
                            webrsp = (HttpWebResponse)webreq.GetResponse();
                        }
                        catch (Exception)
                        {
                            throw new CPS_Exception("Invalid connection string").SetCode(CPS_Exception.ERROR_CODE.INVALID_CONNECTION_STRING);
                        }
                        Stream webrsp_data = webrsp.GetResponseStream();
                        StreamReader webrsp_reader = new StreamReader(webrsp_data);

                        netTimer.Start();
                        rawResponse = webrsp_reader.ReadToEnd();
                        webrsp_reader.Close();
                        netTimer.Stop();
                    }

                    if (this.p_connectionString.Scheme.ToLower() == "tcp" || this.p_connectionString.Scheme.ToLower() == "tcps")
                    {
                        int port = this.p_connectionString.Port;
                        if (port <= 0)
                            port = 5550;
                        TcpClient tcp;
                        try
                        {
                            netTimer.Start();
                            tcp = new TcpClient(this.p_connectionString.Host, port);
                            netTimer.Stop();
                        }
                        catch (SocketException)
                        {
                            netTimer.Stop();
                            throw new CPS_Exception("Cannot connect to specified server").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR);
                        }
                        catch (Exception) // all other cases
                        {
                            netTimer.Stop();
                            throw new CPS_Exception("Invalid connection string").SetCode(CPS_Exception.ERROR_CODE.INVALID_CONNECTION_STRING);
                        }

                        NetworkStream net = tcp.GetStream();
                        System.IO.Stream strm = net;

                        if (this.p_connectionString.Scheme.ToLower() == "tcps")
                        {
                            System.Net.Security.SslStream ssl = new System.Net.Security.SslStream(strm, false, new System.Net.Security.RemoteCertificateValidationCallback(ConnectionServerValidationCallback), null);

                            try
                            {
                                ssl.AuthenticateAsClient(this.p_connectionString.Host);
                            }
                            catch (Exception)
                            {
                                throw new CPS_Exception("Error establishing SSL connection").SetCode(CPS_Exception.ERROR_CODE.SSL_HANDSHAKE);
                            }

                            strm = ssl;
                        }

                        Protobuf pb = new Protobuf();
                        pb.CreateField(1, Protobuf.WireType.LengthDelimited, requestBytes);
                        pb.CreateStringField(2, this.p_storageName);

                        if (this.p_hmacUserKey != null && this.p_hmacSignKey != null)
                        {
                            string characters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
                            char[] tokenchars = new char[16];
                            for (int i = 0; i < 16; i++)
                                tokenchars[i] = characters[this.p_random.Next(characters.Length)];
                            string token = new string(tokenchars);

                            System.DateTime epoch = new System.DateTime(1970, 1, 1, 0, 0, 0, 0).ToUniversalTime();
                            System.DateTime validity = System.DateTime.Now.ToUniversalTime();
                            validity.AddSeconds(10);
                            System.TimeSpan dtdiff = validity - epoch;
                            UInt64 unixvalidity = (UInt64)dtdiff.TotalSeconds;

                            pb.CreateStringField(14, token);
                            pb.CreateFixed64Field(15, unixvalidity);
                            pb.CreateStringField(16, this.p_hmacUserKey);
                            pb.CreateStringField(17, CPS_Hasher.SHA1(CPS_Hasher.SHA1(requestXml) + token + unixvalidity + this.p_hmacSignKey));
                            pb.CreateStringField(18, CPS_Hasher.SHA1_HMAC(this.p_hmacSignKey, requestXml + token + unixvalidity));
                        }

                        MemoryStream ms = new MemoryStream();
                        Protobuf_Streamer pbs = new Protobuf_Streamer(ms);
                        pb.WriteToStream(pbs);

                        byte[] header = CPS_Length2Header((int)(ms.Length));

                        netTimer.Start();
                        try
                        {
                            strm.Write(header, 0, 8);
                            strm.Write(ms.GetBuffer(), 0, (int)(ms.Length));
                        }
                        catch (Exception)
                        {
                            netTimer.Stop();
                            throw new CPS_Exception("Error sending request").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR);
                        }
                        strm.Flush();

                        try
                        {
                            strm.Read(header, 0, 8);
                            netTimer.Stop();
                        }
                        catch (Exception)
                        {
                            netTimer.Stop();
                            throw new CPS_Exception("Error receiving response").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR);
                        }

                        int len = CPS_Header2Length(header);
                        if (len <= 0)
                            throw new CPS_Exception("Invalid response from server").SetCode(CPS_Exception.ERROR_CODE.INVALID_RESPONSE);

                        byte[] recv = new byte[len];
                        int got = 0;
                        netTimer.Start();
                        while (got < len)
                        {
                            int br = 0;
                            try
                            {
                                br = strm.Read(recv, got, len - got);
                                if (br == 0)
                                {
                                    netTimer.Stop();
                                    throw new CPS_Exception("Server unexpectedly closed connection").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR);
                                }
                            }
                            catch (Exception)
                            {
                                netTimer.Stop();
                                throw new CPS_Exception("Error receiving response").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR);
                            }
                            got += br;
                        }
                        strm.Close();
                        netTimer.Stop();

                        ms = new MemoryStream(recv);
                        pbs = new Protobuf_Streamer(ms);
                        pb = new Protobuf(pbs);

                        rawResponse = pb.GetStringField(1);
                    }
                    totTimer.Stop();

                    this.p_lastRequestDuration = totTimer.ElapsedMilliseconds;
                    this.p_lastRequestDuration = this.p_lastRequestDuration / 1000.0;

                    this.p_lastNetworkDuration = netTimer.ElapsedMilliseconds;
                    this.p_lastNetworkDuration = this.p_lastNetworkDuration / 1000.0;

                    this.p_lastResponseSize = rawResponse.Length;

                    if (this.p_debug)
                    {
                        FileStream fs = new FileStream("response.xml", FileMode.Create);
                        byte[] responseBytes = Encoding.UTF8.GetBytes(rawResponse);
                        fs.Write(responseBytes, 0, responseBytes.Length);
                        fs.Close();
                    }
                }
                catch (CPS_Exception e_)
                {
                    e = e_;
                }

                if (this.p_connectionSwitcher != null)
                    quit = !this.p_connectionSwitcher.shouldRetry(rawResponse, e);
                else
                    quit = true;

                if (quit && e != null)
                    throw e;
            }
            while (!quit);

            switch (request.getCommand())
            {
                case "search":
                case "similar":
                    return new CPS_SearchResponse(this, request, rawResponse);
                case "update":
                case "delete":
                case "replace":
                case "partial-replace":
                case "partial-xreplace":
                case "insert":
                case "create-alert":
                case "update-alerts":
                case "delete-alerts":
                    return new CPS_ModifyResponse(this, request, rawResponse);
                case "alternatives":
                    return new CPS_AlternativesResponse(this, request, rawResponse);
                case "list-words":
                    return new CPS_ListWordsResponse(this, request, rawResponse);
                case "status":
                    return new CPS_StatusResponse(this, request, rawResponse);
                case "retrieve":
                case "list-last":
                case "list-first":
                case "retrieve-last":
                case "retrive-first":
                case "lookup":
                case "show-history":
                    return new CPS_LookupResponse(this, request, rawResponse);
                case "search-delete":
                    return new CPS_SearchDeleteResponse(this, request, rawResponse);
                case "list-paths":
                    return new CPS_ListPathsResponse(this, request, rawResponse);
                case "list-facets":
                    return new CPS_ListFacetsResponse(this, request, rawResponse);
                case "list-alerts":
                    return new CPS_Response(this, request, rawResponse);
                    // TODO: change this !!!
                default:
                    CPS_Response ret = new CPS_Response(this, request, rawResponse);
                    // This is explicitly processed here, because of .NET limitations. PHP API changes this directly from CPS_Response constructor.
                    if (request.getCommand() == "begin-transaction" || request.getCommand() == "commit-transaction" || request.getCommand() == "rollback-transaction")
                        this.p_transactionId = ret.getTransactionId();
                    return ret;
            }
        }
Exemple #4
0
 /// <summary>
 /// This is called by CPS_Connection whenever there is a new request to be sent. This method should not be used directly.
 /// </summary>
 /// <param name="request">The request before being rendered.</param>
 public void newRequest(CPS_Request request)
 {
     if (request.getCommand() == "search")
         this.p_retryRequests = true;
     else
         this.p_retryRequests = false;
     if (this.p_numUsed == this.p_connectionStrings.Count)
     {
         this.p_usedConnections.Clear();
         this.p_numUsed = 0;
         this.p_lastReturnedIndex = -1;
         this.p_lastSuccess = false;
     }
 }
Exemple #5
0
        /// <summary>
        /// Creates new instance of CPS Response class.
        /// </summary>
        /// <param name="connection">CPS_Connection class instance.</param>
        /// <param name="request">CPS_Request class instance.</param>
        /// <param name="responseXml">Raw response XML as string.</param>
        public CPS_Response(CPS_Connection connection, CPS_Request request, string responseXml)
        {
            this.p_connection = connection;
            this.p_transactionId = null;
            this.p_simpleXml = new XmlDocument();
            try
            {
                this.p_simpleXml.LoadXml(responseXml);
            }
            catch (Exception)
            {
                throw new CPS_Exception("Received invalid XML response").SetCode(CPS_Exception.ERROR_CODE.INVALID_RESPONSE);
            }

            XmlElement content = null;
            this.p_errors = new List<CPS_SimpleXML>();
            foreach (XmlElement xmle in this.p_simpleXml.DocumentElement.ChildNodes)
            {
                if (xmle.Name == "cps:storage")
                    this.p_storageName = xmle.InnerXml;
                else if (xmle.Name == "cps:command")
                    this.p_command = xmle.InnerXml;
                else if (xmle.Name == "cps:seconds")
                {
                    try
                    {
                        this.p_seconds = float.Parse(xmle.InnerXml, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
                    }
                    catch (Exception)
                    {
                        this.p_seconds = 0;
                    }
                }
                else if (xmle.Name == "cps:error")
                {
                    this.p_errors.Add(new CPS_SimpleXML(xmle));
                }
                else if (xmle.Name == "cps:content")
                    content = xmle;
            }

            foreach (CPS_SimpleXML sxer in this.p_errors)
            {
                string elvl = sxer["level"];
                if (elvl == "REJECTED" || elvl == "FAILED" || elvl == "ERROR" || elvl == "FATAL")
                    throw new CPS_Exception(sxer["message"]).SetCode(sxer["code"]);
            }

            this.p_textParams = new Dictionary<string, string>();
            this.p_contentArray = null;
            this.p_documents = new Dictionary<string, XmlElement>();
            this.p_facets = new Dictionary<string, Dictionary<string, int>>();
            bool saveDocs = true;
            this.p_words = null;
            this.p_wordCounts = new Dictionary<string, int>();
            this.p_aggregate = new Dictionary<string, List<XmlElement>>();

            if (content != null)
            {
                switch (this.p_command)
                {
                    case "update":
                    case "delete":
                    case "insert":
                    case "partial-replace":
                    case "partial-xreplace":
                    case "replace":
                    case "lookup":
                        if (this.p_command != "lookup")
                            saveDocs = false;
                        break;
                    case "search":
                    case "retrieve":
                    case "retrieve-last":
                    case "retrieve-first":
                    case "list-last":
                    case "list-first":
                    case "similar":
                    case "show-history":
                    case "cursor-next-batch":
                        // In PHP here comes document extraction. In C# document extraction is later, so nothing to do here
                        break;
                    case "alternatives":
                        Dictionary<string, Dictionary<string, CPS_AlternativesResponse.WordInfo>> alt_words = new Dictionary<string, Dictionary<string, CPS_AlternativesResponse.WordInfo>>();
                        foreach (XmlElement xaltlist in content.ChildNodes)
                            foreach (XmlElement xalt in xaltlist.ChildNodes)
                            {
                                if (xalt.Name == "alternatives")
                                {
                                    Dictionary<string, CPS_AlternativesResponse.WordInfo> winfo = new Dictionary<string, CPS_AlternativesResponse.WordInfo>();
                                    XmlElement xto = xalt["to"];
                                    if (xto == null)
                                        continue;
                                    XmlElement xto_count = xalt["count"];
                                    if (xto_count == null)
                                        continue;

                                    int ito_count = 0;
                                    try
                                    {
                                        ito_count = int.Parse(xto_count.InnerXml);
                                    }
                                    catch (Exception)
                                    {
                                        continue;
                                    }

                                    foreach (XmlElement xword in xalt.ChildNodes)
                                    {
                                        if (xword.Name == "word")
                                        {
                                            XmlAttribute xcount = xword.Attributes["count"];
                                            XmlAttribute xcr = xword.Attributes["cr"];
                                            XmlAttribute xidif = xword.Attributes["idif"];
                                            XmlAttribute xh = xword.Attributes["h"];
                                            if (xcount == null || xcr == null || xidif == null || xh == null)
                                                continue;

                                            CPS_AlternativesResponse.WordInfo info = new CPS_AlternativesResponse.WordInfo();
                                            info.word = xword.InnerXml;

                                            try
                                            {
                                                info.count = int.Parse(xcount.Value);
                                                info.cr = float.Parse(xcr.Value, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
                                                info.idif = float.Parse(xidif.Value, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
                                                info.h = float.Parse(xh.Value, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
                                            }
                                            catch (Exception)
                                            {
                                                continue;
                                            }

                                            winfo[info.word] = info;
                                        }
                                    }

                                    alt_words[xto.InnerXml] = winfo;
                                    this.p_wordCounts[xto.InnerXml] = ito_count;
                                }
                            }
                        this.p_words = alt_words;
                        break;
                    case "list-words":
                        Dictionary<string, Dictionary<string, CPS_ListWordsResponse.WordInfo>> list_words = new Dictionary<string, Dictionary<string, CPS_ListWordsResponse.WordInfo>>();
                        foreach (XmlElement xlist in content.ChildNodes)
                        {
                            if (xlist.Name == "list")
                            {
                                Dictionary<string, CPS_ListWordsResponse.WordInfo> winfo = new Dictionary<string, CPS_ListWordsResponse.WordInfo>();
                                XmlAttribute xto = xlist.Attributes["to"];
                                if (xto == null)
                                    continue;

                                foreach (XmlElement xword in xlist.ChildNodes)
                                {
                                    if (xword.Name == "word")
                                    {
                                        XmlAttribute xcount = xword.Attributes["count"];
                                        if (xcount == null)
                                            continue;

                                        CPS_ListWordsResponse.WordInfo info = new CPS_ListWordsResponse.WordInfo();
                                        info.word = xword.InnerXml;

                                        try
                                        {
                                            info.count = int.Parse(xcount.Value);
                                        }
                                        catch (Exception)
                                        {
                                            continue;
                                        }

                                        winfo[info.word] = info;
                                    }
                                }

                                list_words[xto.Value] = winfo;
                            }
                        }
                        this.p_words = list_words;
                        break;
                    case "status":
                    case "list-paths":
                    case "list-databases":
                    case "create-database":
                    case "edit-database":
                    case "rename-database":
                    case "drop-database":
                    case "describe-database":
                    case "list-nodes":
                    case "list-hubs":
                    case "list-hosts":
                    case "set-offline":
                    case "set-online":
                    case "list-alerts":
                        this.p_contentArray = content;
                        break;
                    case "begin-transaction":
                        try
                        {
                            this.p_transactionId = content["transaction_id"].InnerXml;
                        }
                        catch (Exception)
                        {
                            this.p_transactionId = null;
                        }
                        break;
                    case "commit-transaction":
                    case "rollback-transaction":
                        this.p_transactionId = null;
                        break;
                    default:
                        // nothing special
                        break;
                }

                if (this.p_command == "search" || this.p_command == "list-facets")
                {
                    foreach (XmlElement xmle in content.ChildNodes)
                    {
                        if (xmle.Name == "facet")
                        {
                            XmlAttribute xattr = xmle.Attributes["path"];
                            if (xattr == null || xattr.Value.Length <= 0)
                                continue;

                            string path = xattr.Value;
                            this.p_facets[path] = new Dictionary<string, int>();

                            foreach (XmlElement xmlt in xmle.ChildNodes)
                            {
                                if (xmlt.Name == "term")
                                {
                                    this.p_facets[path][xmlt.InnerXml] = 0;

                                    if (this.p_command == "search")
                                    {
                                        xattr = xmlt.Attributes["hits"];
                                        if (xattr != null && xattr.Value.Length > 0)
                                        {
                                            try
                                            {
                                                this.p_facets[path][xmlt.InnerXml] = int.Parse(xattr.Value);
                                            }
                                            catch (Exception)
                                            {
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        if (xmle.Name == "aggregate")
                        {
                            string query = "";
                            try
                            {
                                XmlElement qel = xmle["query"];
                                if (qel != null)
                                    query = qel.InnerXml;
                            }
                            catch (Exception)
                            {
                            }

                            if (query.Length > 0)
                            {
                                this.p_aggregate[query] = new List<XmlElement>();
                                foreach (XmlElement xmld in xmle.ChildNodes)
                                    if (xmld.Name == "data")
                                        this.p_aggregate[query].Add(xmld);
                            }
                        }
                    }
                }

                foreach (XmlElement xmle in content.ChildNodes)
                {
                    if (Array.Exists<string>(CPS_Response.p_textParamNames, pn => pn == xmle.Name))
                        this.p_textParams[xmle.Name] = xmle.InnerXml;
                    else if (xmle.Name == "results")
                    {
                        foreach (XmlElement xmld in xmle.ChildNodes)
                            this.ProcessRawDocument(connection, xmld, saveDocs);
                    }
                    else if (xmle.Name == connection.getDocumentRootXpath())
                        this.ProcessRawDocument(connection, xmle, saveDocs);
                }
            }
        }
 /// <summary>
 /// Creates new CPS_ModifyResponse class instance.
 /// </summary>
 /// <param name="connection">CPS_Connection class instance.</param>
 /// <param name="request">CPS_Request class instance.</param>
 /// <param name="responseXml">Raw response XML as string.</param>
 public CPS_ModifyResponse(CPS_Connection connection, CPS_Request request, string responseXml)
     : base(connection, request, responseXml)
 {
 }
 /// <summary>
 /// Creates new CPS_ListWordsResponse class instance.
 /// </summary>
 /// <param name="connection">CPS_Connection class instance.</param>
 /// <param name="request">CPS_Request class instance.</param>
 /// <param name="responseXml">Raw response XML as string.</param>
 public CPS_ListWordsResponse(CPS_Connection connection, CPS_Request request, string responseXml)
     : base(connection, request, responseXml)
 {
 }
 /// <summary>
 /// Creates new CPS_EmptyResponse class instance.
 /// </summary>
 /// <param name="connection">CPS_Connection class instance.</param>
 /// <param name="request">CPS_Request class instance.</param>
 public CPS_EmptyResponse(CPS_Connection connection, CPS_Request request)
     : base(connection, request)
 {
 }
 /// <summary>
 /// Creates new CPS_SearchDeleteResponse class instance.
 /// </summary>
 /// <param name="connection">CPS_Connection class instance.</param>
 /// <param name="request">CPS_Request class instance.</param>
 /// <param name="responseXml">Raw response XML as string.</param>
 public CPS_SearchDeleteResponse(CPS_Connection connection, CPS_Request request, string responseXml)
     : base(connection, request, responseXml)
 {
 }
Exemple #10
0
 /// <summary>
 /// Creates new CPS_AlternativesResponse class instance.
 /// </summary>
 /// <param name="connection">CPS_Connection class instance.</param>
 /// <param name="request">CPS_Request class instance.</param>
 /// <param name="responseXml">Raw response XML as string.</param>
 public CPS_AlternativesResponse(CPS_Connection connection, CPS_Request request, string responseXml)
     : base(connection, request, responseXml)
 {
     this.p_localWords = null;
 }