amps-python-client 5.3.4.1__zip

amps-python-client-5.3.4.1/src/cpp/src/uri.c

@@ -0,0 +1,301 @@
+/** ////////////////////////////////////////////////////////////////////////
+ *
+ * Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+ *
+ * This computer software is owned by 60East Technologies Inc. and is
+ * protected by U.S. copyright laws and other laws and by international
+ * treaties.  This computer software is furnished by 60East Technologies
+ * Inc. pursuant to a written license agreement and may be used, copied,
+ * transmitted, and stored only in accordance with the terms of such
+ * license agreement and with the inclusion of the above copyright notice.
+ * This computer software or any other copies thereof may not be provided
+ * or otherwise made available to any other person.
+ *
+ * U.S. Government Restricted Rights.  This computer software: (a) was
+ * developed at private expense and is in all respects the proprietary
+ * information of 60East Technologies Inc.; (b) was not developed with
+ * government funds; (c) is a trade secret of 60East Technologies Inc.
+ * for all purposes of the Freedom of Information Act; and (d) is a
+ * commercial item and thus, pursuant to Section 12.212 of the Federal
+ * Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+ * Government's use, duplication or disclosure of the computer software
+ * is subject to the restrictions set forth by 60East Technologies Inc..
+ *
+ * ////////////////////////////////////////////////////////////////////// */
+#include <amps/ampsuri.h>
+#include <assert.h>
+
+AMPSDLL void
+amps_uri_parse(const char* pUri_, size_t uriLength_, amps_uri_state* pUriState_)
+{
+  const char* ch = NULL;
+  const char* pEnd = pUri_ + uriLength_;
+  if (pUriState_->part_id == AMPS_URI_START)
+  {
+    pUriState_->part = pUri_;
+    pUriState_->part_length = 0;
+  }
+  ch = pUriState_->part + pUriState_->part_length;
+  switch (pUriState_->part_id)
+  {
+  case AMPS_URI_START:
+    while (ch < pEnd)
+    {
+      if (*ch == ':')
+      {
+        pUriState_->part_length = (size_t)(ch - pUri_);
+        pUriState_->part_id     = AMPS_URI_TRANSPORT;
+        return;
+      }
+      ++ch;
+    }
+    pUriState_->part_id = AMPS_URI_ERROR;
+    break;
+  case AMPS_URI_TRANSPORT:
+    ++ch;
+    while (ch < pEnd && *++ch == '/');
+    pUriState_->part = ch;
+    while (ch < pEnd)
+    {
+      if (*ch == '[')
+      {
+        pUriState_->part = ++ch;
+        while (ch < pEnd && *++ch != ']');
+        pUriState_->part_id = ch >= pEnd ? AMPS_URI_ERROR : AMPS_URI_HOST;
+        pUriState_->part_length = (size_t)(ch - pUriState_->part);
+        return;
+      }
+      else if (*ch == ':')
+      {
+        const char* next = NULL;
+        pUriState_->part_length = (size_t)(ch - pUriState_->part);
+        next = ch + 1;
+        while (next < pEnd)
+        {
+          if (*next == '@')
+          {
+            pUriState_->part_id = AMPS_URI_USER;
+            return;
+          }
+          if (*next == '/')
+          {
+            pUriState_->part_id = AMPS_URI_HOST;
+            return;
+          }
+          ++next;
+        }
+      }
+      else if (*ch == '@')
+      {
+        pUriState_->part_length = (size_t)(ch - pUriState_->part);
+        pUriState_->part_id = AMPS_URI_USER;
+        return;
+      }
+      ++ch;
+    }
+    pUriState_->part_id = AMPS_URI_ERROR;
+    break;
+  case AMPS_URI_USER:
+    if (*ch == '@')
+    {
+      ++ch;
+      if (*ch == '[')
+      {
+        pUriState_->part = ++ch;
+        while (ch < pEnd && *++ch != ']');
+      }
+      else
+      {
+        pUriState_->part = ch;
+        while (ch < pEnd && *++ch != ':');
+      }
+      pUriState_->part_id = ch >= pEnd ? AMPS_URI_ERROR : AMPS_URI_HOST;
+      pUriState_->part_length = (size_t)(ch - pUriState_->part);
+    }
+    else
+    {
+      pUriState_->part_id = AMPS_URI_PASSWORD;
+      pUriState_->part = ++ch;
+      while (ch < pEnd && *ch != '@')
+      {
+        ++ch;
+      }
+      pUriState_->part_length = (size_t)(ch - pUriState_->part);
+    }
+    break;
+  case AMPS_URI_PASSWORD:
+    assert(*ch == '@');
+    ++ch;
+    if (*ch == '[')
+    {
+      pUriState_->part = ++ch;
+      while (ch < pEnd && *++ch != ']');
+    }
+    else
+    {
+      pUriState_->part = ch;
+      while (ch < pEnd && *++ch != ':');
+    }
+    pUriState_->part_id = ch >= pEnd ? AMPS_URI_ERROR : AMPS_URI_HOST;
+    pUriState_->part_length = (size_t)(ch - pUriState_->part);
+    break;
+  case AMPS_URI_HOST:
+    if (*ch == ']')
+    {
+      ++ch;
+    }
+    assert(*ch == ':');
+    ++ch;
+    pUriState_->part = ch;
+    while (ch < pEnd)
+    {
+      if (*ch == '/')
+      {
+        pUriState_->part_id = AMPS_URI_PORT;
+        pUriState_->part_length = (size_t)(ch - pUriState_->part);
+        return;
+      }
+      ++ch;
+    }
+    pUriState_->part_id = AMPS_URI_ERROR;
+    break;
+  case AMPS_URI_PORT:
+    assert(*ch == '/');
+    ++ch;
+    pUriState_->part = ch;
+    while (ch < pEnd)
+    {
+      if (*ch == '/' || *ch == '?')
+      {
+        break;
+      } ++ch;
+    }
+    pUriState_->part_id = AMPS_URI_PROTOCOL;
+    pUriState_->part_length = (size_t)(ch - pUriState_->part);
+    break;
+  case AMPS_URI_PROTOCOL:
+    if (ch == pEnd)
+    {
+      pUriState_->part_id = AMPS_URI_END;
+    }
+    else if (*ch == '?')
+    {
+      ++ch;
+      pUriState_->part = ch;
+      pUriState_->part_id = AMPS_URI_OPTION_KEY;
+      while (ch < pEnd)
+      {
+        if (*ch == '=')
+        {
+          pUriState_->part_length = (size_t)(ch - pUriState_->part);
+          return;
+        }
+        ++ch;
+      }
+      pUriState_->part_id = AMPS_URI_ERROR;
+    }
+    else
+    {
+      assert(*ch == '/');
+      ++ch;
+      pUriState_->part = ch;
+      while (ch < pEnd)
+      {
+        if (*ch == '/' || *ch == '?')
+        {
+          break;
+        } ++ch;
+      }
+      pUriState_->part_id = AMPS_URI_MESSAGE_TYPE;
+      pUriState_->part_length = (size_t)(ch - pUriState_->part);
+    }
+    break;
+  case AMPS_URI_MESSAGE_TYPE:
+    if (ch + 1 >= pEnd)
+    {
+      pUriState_->part_id = AMPS_URI_END;
+    }
+    else
+    {
+      if (*ch == '/')
+      {
+        ++ch;
+      }
+      if (*ch++ != '?')
+      {
+        pUriState_->part_id = AMPS_URI_ERROR;
+        return;
+      }
+      pUriState_->part = ch;
+      pUriState_->part_id = AMPS_URI_OPTION_KEY;
+      while (ch < pEnd)
+      {
+        if (*ch == '=')
+        {
+          pUriState_->part_length = (size_t)(ch - pUriState_->part);
+          return;
+        }
+        ++ch;
+      }
+      pUriState_->part_id = ch > pUriState_->part ? AMPS_URI_ERROR : AMPS_URI_END;
+    }
+    break;
+  case AMPS_URI_OPTION_KEY:
+    assert(*ch == '=');
+    pUriState_->part = ++ch;
+    while (ch < pEnd && *ch != '&')
+    {
+      ++ch;
+    }
+    pUriState_->part_id = AMPS_URI_OPTION_VALUE;
+    pUriState_->part_length = (size_t)(ch - pUriState_->part);
+    break;
+  case AMPS_URI_OPTION_VALUE:
+    if (ch + 1 >= pEnd)
+    {
+      pUriState_->part_id = AMPS_URI_END;
+    }
+    else
+    {
+      pUriState_->part = ++ch;
+      while (ch < pEnd && *++ch != '=');
+      pUriState_->part_length = (size_t)(ch - pUriState_->part);
+      pUriState_->part_id = ch >= pEnd ? AMPS_URI_ERROR : AMPS_URI_OPTION_KEY;
+    }
+    break;
+  default:
+    pUriState_->part_id = AMPS_URI_ERROR;
+    break;
+  }
+  return;
+}
+/*
+static const char* amps_uri_part_names[] = {
+  "start",
+  "transport",
+  "user",
+  "password",
+  "host",
+  "port",
+  "protocol",
+  "message type",
+  "option key",
+  "option value",
+  "ERROR",
+  "end"
+};
+int main(int argc, char**argv)
+{
+  amps_uri_state state;
+  memset(&state, 0, sizeof(amps_uri_state));
+
+  while(state.part_id < AMPS_URI_ERROR)
+  {
+    amps_uri_parse(argv[1],strlen(argv[1]),&state);
+    printf("%12s [%.*s]\n", amps_uri_part_names[state.part_id],
+        (int)state.part_length,
+        state.part);
+  }
+  return 0;
+}
+*/

amps-python-client-5.3.4.1/src/exponentialdelaystrategy.cpp

@@ -0,0 +1,137 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#define PY_SSIZE_T_CLEAN 1
+#include <Python.h>
+#include <amps/ampsplusplus.hpp>
+#include <ampspy_types.hpp>
+#include <ampspy_defs.hpp>
+#include <amps/ReconnectDelayStrategy.hpp>
+#include <amps/ReconnectDelayStrategyImpl.hpp>
+
+
+using namespace AMPS;
+namespace ampspy
+{
+  namespace exponentialdelaystrategy
+  {
+
+    AMPSDLL ampspy::ampspy_type_object type;
+
+//    def __init__(self, name):
+    static int ctor(obj* self, PyObject* args, PyObject* kwds)
+    {
+      static const char* kwargs[] = { "initial_delay", "maximum_delay",
+                                      "backoff_exponent", "maximum_retry_time", "jitter", NULL
+                                    };
+      unsigned long initial_delay = 200, maximum_delay = 20 * 1000,
+                    maximum_retry_time = 0;
+      double backoff_exponent = 2.0;
+      double jitter = 1.0;
+
+      if (!PyArg_ParseTupleAndKeywords(args, kwds, "|IIdId", (char**)kwargs,
+                                       &initial_delay, &maximum_delay, &backoff_exponent, &maximum_retry_time,
+                                       &jitter))
+      {
+        return -1;
+      }
+      new (&(self->impl)) ReconnectDelayStrategy(
+        new AMPS::ExponentialDelayStrategy(initial_delay, maximum_delay,
+                                           backoff_exponent, maximum_retry_time, jitter));
+      return 0;
+    }
+    static void dtor(obj* self)
+    {
+      self->impl.~ReconnectDelayStrategy();
+      shims::free(self);
+    }
+
+    static PyObject* get_connect_wait_duration(obj* self, PyObject* args)
+    {
+      const char* uri = NULL;
+      if (!PyArg_ParseTuple(args, "s", &uri))
+      {
+        return NULL;
+      }
+      CALL_RETURN_SIZE_T( self->impl.getConnectWaitDuration(uri) );
+    }
+
+    static PyObject* reset(obj* self, PyObject* args)
+    {
+      self->impl.reset();
+      NONE;
+    }
+
+    static const char* docstring =
+      "ExponentialDelayStrategy is an implementation that exponentially\n"
+      "backs off when reconnecting to the same server, with a maximum\n"
+      "time to retry before it gives up entirely.\n\n"
+      "By default, an ExponentialDelayStrategy has an initial delay of\n"
+      "200 ms, a maximum delay of  20 seconds, a backoff exponent of\n"
+      "2.0, and has no limit to the amount of time to retry the connection.\n"
+      "\n"
+      "Constructor parameters:\n\n"
+      ":param initial_delay:      The time (in milliseconds) to wait before\n"
+      "                           reconnecting to a server for the first\n"
+      "                           time after a failed connection.\n\n"
+      ":param maximum_delay:      The maximum time to wait for any reconnect\n"
+      "                           attempt (milliseconds). Exponential\n"
+      "                           backoff will not exceed this maximum.\n\n"
+      ":param backoff_exponent:   The exponent to use for calculating the\n"
+      "                           next delay time. For example, if the\n"
+      "                           initial time is 200ms and the exponent\n"
+      "                           is 2.0, the next delay will be 400ms,\n"
+      "                           then 800ms, etc.\n\n"
+      ":param maximum_retry_time: The maximum time (milliseconds) to allow\n"
+      "                           reconnect attempts to continue without\n"
+      "                           a successful connection, before \"giving\n"
+      "                           up\" and abandoning the connection attempt.\n\n"
+      ":param jitter:             The amount of 'jitter' to apply when\n"
+      "                           calculating a delay time, measured in multiples\n"
+      "                           of the initial delay. Jitter is used to reduce\n"
+      "                           the number of simultaneous reconnects that may\n"
+      "                           be issued from multiple clients.\n\n\n";
+
+    void add_types(PyObject* module_)
+    {
+      type.setName("AMPS.ExponentialDelayStrategy")
+      .setBasicSize(sizeof(obj))
+      .setDestructorFunction(dtor)
+      .setConstructorFunction(ctor)
+      .setBaseType()
+      .setDoc(docstring)
+      .notCopyable()
+      .addMethod("get_connect_wait_duration", get_connect_wait_duration,
+                 "Returns the time that the client should delay before connecting "
+                 "to the given server URI.")
+      .addMethod("reset", reset, "Reset the state of this reconnect delay. AMPS calls this "
+                 "method when a connection is established.")
+      .createType()
+      .registerType("ExponentialDelayStrategy", module_);
+    }
+
+  } // namespace exponentialdelaystrategy
+
+} // namespace ampspy

amps-python-client-5.3.4.1/src/failedwritehandler.cpp

@@ -0,0 +1,116 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2016-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#define PY_SSIZE_T_CLEAN 1
+#include <Python.h>
+#include <amps/ampsplusplus.hpp>
+#include <ampspy_types.hpp>
+#include <ampspy_defs.hpp>
+namespace ampspy
+{
+  PyFailedWriteHandler::PyFailedWriteHandler(PyObject* self_)
+    : _self(self_), _newStyle(true), _message(NULL)
+  {
+    LOCKGIL;
+    Py_INCREF(_self);
+    _message = (ampspy::message::obj*)_PyObject_New(ampspy::message::message_type);
+    _message->isOwned = false;
+  }
+
+  PyFailedWriteHandler::~PyFailedWriteHandler()
+  {
+    // we need a python thread state in order to do this
+    try
+    {
+      LOCKGIL;
+      Py_DECREF(_self);
+    }
+    catch (...)
+    {
+      // LOCKGIL will throw if python is shutting down; avoid this.
+    }
+  }
+
+  void
+  PyFailedWriteHandler::failedWrite(const AMPS::Message& message_,
+                                    const char* reason_, size_t reasonLength_)
+  {
+    PyObject* returnValue = NULL;
+    LOCKGIL;
+    if (_newStyle)
+    {
+      _message->pMessage = (AMPS::Message*)&message_;
+      returnValue = PyObject_CallFunction(_self, (char*)"(Os#)",
+                                          _message, reason_, reasonLength_);
+      if (returnValue)
+      {
+        Py_XDECREF(returnValue);
+        return;
+      }
+      if (PyErr_ExceptionMatches(PyExc_TypeError))
+      {
+        // This will fall through
+        _newStyle = false;
+        PyErr_Clear();
+      }
+      else if (PyErr_ExceptionMatches(PyExc_SystemExit))
+      {
+        ampspy::unhandled_exception();
+      }
+      else
+      {
+        exc::throwError();
+      }
+    }
+    const char* topic, *data, *correlationId;
+    size_t topicLength, dataLength, correlationIdLength;
+    message_.getRawTopic(&topic, &topicLength);
+    message_.getRawData(&data, &dataLength);
+    message_.getRawCorrelationId(&correlationId, &correlationIdLength);
+    amps_uint64_t sequence = amps_message_get_field_uint64(message_.getMessage(),
+                                                           AMPS_Sequence);
+    returnValue = PyObject_CallFunction(_self, (char*)"(Kbs#s#s#s#)",
+                                        sequence,
+                                        (char)message_.getCommandEnum(),
+                                        topic, topicLength,
+                                        data, dataLength,
+                                        correlationId, correlationIdLength,
+                                        reason_, reasonLength_);
+    if (returnValue == NULL)
+    {
+      if (PyErr_ExceptionMatches(PyExc_SystemExit))
+      {
+        ampspy::unhandled_exception();
+      }
+      else // includes PyExc_TypeError
+      {
+        exc::throwError();
+      }
+    }
+    Py_XDECREF(returnValue);
+  }
+
+} // namespace ampspy
+

amps-python-client-5.3.4.1/src/fixbuilder.cpp

@@ -0,0 +1,146 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#define PY_SSIZE_T_CLEAN 1
+#include <Python.h>
+#include <amps/ampsplusplus.hpp>
+#include <ampspy_types.hpp>
+#include <ampspy_defs.hpp>
+
+using namespace AMPS;
+namespace ampspy
+{
+  namespace fixbuilder
+  {
+
+    static ampspy::ampspy_type_object fixbuilder_type;
+//    def __init__(self, name):
+    static int _ctor(obj* self, PyObject* args, PyObject* kwds)
+    {
+      char fieldSep(1);
+      self->pFIXBuilder = NULL;
+      if (!PyArg_ParseTuple(args, "|c", &fieldSep))
+      {
+        return -1;
+      }
+      self->pFIXBuilder = new FIXBuilder(fieldSep);
+      return 0;
+    }
+
+    static void _dtor(obj* self)
+    {
+      delete self->pFIXBuilder;
+      shims::free(self);
+    }
+
+//    def append(self, tag, value, offset, length)
+    static PyObject* append(obj* self, PyObject* args)
+    {
+      int tag = 0;
+      PyObject* valObj = NULL;
+      const char* value = NULL;
+      size_t offset = 0;
+      size_t length = 0;
+      if (!PyArg_ParseTuple(args, "iO|kk", &tag, &valObj, &offset, &length))
+      {
+        return NULL;
+      }
+      PyObject* newString = NULL;
+      if (PyString_Check(valObj))
+      {
+        value = PyString_AsString(valObj);
+      }
+      else
+      {
+        newString = PyObject_Str(valObj);
+        if (newString)
+        {
+          value = PyString_AsString(newString);
+        }
+      }
+      if (value)
+      {
+        if (length == 0)
+        {
+          std::string val(value);
+          self->pFIXBuilder->append(tag, val);
+        }
+        else
+        {
+          self->pFIXBuilder->append(tag, value, offset, length);
+        }
+      }
+      Py_XDECREF(newString);
+      Py_INCREF((PyObject*)self);
+      return (PyObject*)self;
+    }
+
+//  def get_string(self)
+    static PyObject* get_string(obj* self, PyObject* args)
+    {
+      CALL_RETURN_STRING(self->pFIXBuilder->getString());
+    }
+
+//  def reset(self)
+    static PyObject* reset(obj* self, PyObject* args)
+    {
+      CALL_RETURN_NONE(self->pFIXBuilder->reset());
+    }
+
+    static PyObject* str(PyObject* builder)
+    {
+      obj* self = (obj*)builder;
+      CALL_RETURN_STRING(self->pFIXBuilder->getString());
+    }
+    void add_types(PyObject* module_)
+    {
+      fixbuilder_type.setName("AMPS.FIXBuilder")
+      .setBasicSize(sizeof(obj))
+      .setDestructorFunction(_dtor)
+      .setConstructorFunction(_ctor)
+      .setStrFunction(str)
+      .setReprFunction(str)
+      .setBaseType()
+      .setDoc("AMPS FIXBuilder Object")
+      .addMethod("append", append,
+                 "append(tag,value,(optional)offset,(optional)length)\n\nAppends tag=value to self.\n"
+                 ":param tag: The numeric tag to use.\n:type tag: int\n"
+                 ":param value: The value for the given tag.\n:type value: str\n"
+                 ":param offset: Optional. The offset into value at which the value actually starts.\n:type offset: int\n"
+                 ":param length: Optional. The length of the actual value within value. Only valid and required if offset is also provided\n:type tag: int\n")
+      .addMethod("get_string", get_string,
+                 "get_string()\n\n"
+                 "Called to get the string FIX message.\n\n"
+                 ":returns: The FIX message as a string.\n")
+      .addMethod("reset", reset,
+                 "reset()\n\n"
+                 "Called to clear the state of the FIXBuilder to create a new FIX message\n")
+      .notCopyable()
+      .createType()
+      .registerType("FIXBuilder", module_);
+    }
+
+  } // namespace fixbuilder
+} // namespace ampspy