Re: [PATCH] OpenSource MamaFieldCache in MAMA 6 - C/CPP


Gary Molloy <GMolloy@...>
 

Also please note that there are unittests available for the fieldcache

 

From: Gary Molloy
Sent: 02 April 2014 17:22
To: openmama-dev@...
Subject: FW: [PATCH] OpenSource MamaFieldCache in MAMA 6 - C/CPP

 

Including test strategy:

 

This is not OS dependant
This is not middleware dependant


If you build MAMA you will have mamalistencachedc and mamalistencachedcpp in the bin directory. Try running these up against a feedhandler and they should work just fine.

You will also have the following directory which will include all the fieldcache header files:

<install>/include/mama/fieldcache

You will also have the .c and .cpp files in the <install>/examples/mama/c and <install>/examples/mama/cpp directories which you can compile

 

 

From: Gary Molloy
Sent: 02 April 2014 16:51
To: openmama-dev@...
Subject: [PATCH] OpenSource MamaFieldCache in MAMA 6 - C/CPP

 

From feb963ab29ec5423822307b18b866f0000fbefd6 Mon Sep 17 00:00:00 2001

From: Gary Molloy <gmolloy@...>

Date: Wed, 2 Apr 2014 16:28:43 +0100

Subject: [PATCH] OpenSource MamaFieldCache for C and CPP

 

Open Source the MAMA FieldCache for C and CPP

 

[OMAMA-253]

 

Signed-off-by: Gary Molloy <gmolloy@...>

---

mama/c_cpp/configure.ac                            |    2 +

mama/c_cpp/src/c/Makefile.am                       |   21 +-

mama/c_cpp/src/c/SConscript                        |   22 +

mama/c_cpp/src/c/SConscript.win                    |   14 +

mama/c_cpp/src/c/fieldcache/fieldcache.c           |  552 ++++

mama/c_cpp/src/c/fieldcache/fieldcachefield.c      | 1507 +++++++++++

mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.c  |  122 +

mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.h  |  138 +

mama/c_cpp/src/c/fieldcache/fieldcacheimpl.c       |  687 +++++

mama/c_cpp/src/c/fieldcache/fieldcacheimpl.h       |   92 +

mama/c_cpp/src/c/fieldcache/fieldcacheiterator.c   |   77 +

.../src/c/fieldcache/fieldcacheiteratorimpl.h      |   57 +

mama/c_cpp/src/c/fieldcache/fieldcachelist.c       |   95 +

mama/c_cpp/src/c/fieldcache/fieldcachelist.h       |  135 +

mama/c_cpp/src/c/fieldcache/fieldcachemap.c        |   96 +

mama/c_cpp/src/c/fieldcache/fieldcachemap.h        |  113 +

mama/c_cpp/src/c/fieldcache/fieldcachemaparray.c   |  263 ++

mama/c_cpp/src/c/fieldcache/fieldcachemaparray.h   |   90 +

mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.c  |   79 +

mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.h  |   72 +

mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.c |   74 +

mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.h |   64 +

mama/c_cpp/src/c/fieldcache/fieldcacherecord.c     |  159 ++

mama/c_cpp/src/c/fieldcache/fieldcacherecordimpl.h |   49 +

mama/c_cpp/src/c/fieldcache/fieldcachevector.c     |  127 +

mama/c_cpp/src/c/fieldcache/fieldcachevector.h     |  134 +

mama/c_cpp/src/c/mama/fieldcache/fieldcache.h      |  368 +++

mama/c_cpp/src/c/mama/fieldcache/fieldcachefield.h | 1093 ++++++++

.../src/c/mama/fieldcache/fieldcacheiterator.h     |  102 +

.../c_cpp/src/c/mama/fieldcache/fieldcacherecord.h |  152 ++

mama/c_cpp/src/c/mama/fieldcache/fieldcachetypes.h |   52 +

mama/c_cpp/src/c/mamac.vcproj                      |  108 +

mama/c_cpp/src/cpp/Makefile.am                     |   13 +-

mama/c_cpp/src/cpp/SConscript                      |   14 +

mama/c_cpp/src/cpp/SConscript.win                  |    6 +

mama/c_cpp/src/cpp/fieldcache/MamaFieldCache.cpp   |  310 +++

.../src/cpp/fieldcache/MamaFieldCacheField.cpp     |  229 ++

.../cpp/fieldcache/MamaFieldCacheFieldTypes.cpp    |  873 ++++++

.../src/cpp/fieldcache/MamaFieldCacheRecord.cpp    |  152 ++

.../c_cpp/src/cpp/mama/fieldcache/MamaFieldCache.h |  332 +++

.../src/cpp/mama/fieldcache/MamaFieldCacheField.h  |  216 ++

.../cpp/mama/fieldcache/MamaFieldCacheFieldTypes.h | 1079 ++++++++

.../src/cpp/mama/fieldcache/MamaFieldCacheRecord.h |  130 +

mama/c_cpp/src/cpp/mamacpp.vcproj                  |   32 +

mama/c_cpp/src/examples/c/Makefile.am              |    5 +-

mama/c_cpp/src/examples/c/Makefile.sample          |    7 +-

mama/c_cpp/src/examples/c/SConscript               |    3 +-

mama/c_cpp/src/examples/c/SConscript.win           |    1 +

mama/c_cpp/src/examples/c/mamalistencachedc.c      | 2839 ++++++++++++++++++++

mama/c_cpp/src/examples/c/mamalistencachedc.vcproj |  373 +++

.../src/examples/c/openmamalistencachedc.vcproj    |  365 +++

mama/c_cpp/src/examples/cpp/Makefile.am            |    5 +-

mama/c_cpp/src/examples/cpp/Makefile.sample        |    5 +-

mama/c_cpp/src/examples/cpp/SConscript             |    2 +-

mama/c_cpp/src/examples/cpp/SConscript.win         |    1 +

.../c_cpp/src/examples/cpp/mamalistencachedcpp.cpp | 2313 ++++++++++++++++

.../src/examples/cpp/mamalistencachedcpp.vcproj    |  373 +++

.../examples/cpp/openmamalistencachedcpp.vcproj    |  369 +++

mama/c_cpp/src/gunittest/c/Makefile.am             |    2 +-

mama/c_cpp/src/gunittest/c/SConscript              |    7 +

mama/c_cpp/src/gunittest/c/fieldcache/Makefile.am  |   54 +

.../src/gunittest/c/fieldcache/Makefile.sample     |   84 +

.../gunittest/c/fieldcache/fieldcachefieldtest.cpp | 1726 ++++++++++++

.../c/fieldcache/fieldcacheiteratortest.cpp        |  190 ++

.../gunittest/c/fieldcache/fieldcachelisttest.cpp  |  165 ++

.../gunittest/c/fieldcache/fieldcachemaptest.cpp   |  324 +++

.../c/fieldcache/fieldcacherecordtest.cpp          |  228 ++

.../src/gunittest/c/fieldcache/fieldcachetest.cpp  | 1090 ++++++++

.../c/fieldcache/fieldcachevectortest.cpp          |  264 ++

mama/c_cpp/src/gunittest/cpp/Makefile.am           |    2 +

.../c_cpp/src/gunittest/cpp/fieldcache/Makefile.am |   52 +

.../src/gunittest/cpp/fieldcache/Makefile.sample   |   77 +

.../cpp/fieldcache/MamaFieldCacheFieldTest.cpp     |  225 ++

.../fieldcache/MamaFieldCacheFieldTypesTest.cpp    | 1087 ++++++++

.../cpp/fieldcache/MamaFieldCacheIteratorTest.cpp  |  290 ++

.../cpp/fieldcache/MamaFieldCacheRecordTest.cpp    |  128 +

.../cpp/fieldcache/MamaFieldCacheTest.cpp          |  351 +++

77 files changed, 23098 insertions(+), 11 deletions(-)

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcache.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachefield.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcacheimpl.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcacheimpl.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcacheiterator.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcacheiteratorimpl.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachelist.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachelist.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemap.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemap.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemaparray.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemaparray.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcacherecord.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcacherecordimpl.h

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachevector.c

create mode 100644 mama/c_cpp/src/c/fieldcache/fieldcachevector.h

create mode 100644 mama/c_cpp/src/c/mama/fieldcache/fieldcache.h

create mode 100644 mama/c_cpp/src/c/mama/fieldcache/fieldcachefield.h

create mode 100644 mama/c_cpp/src/c/mama/fieldcache/fieldcacheiterator.h

create mode 100644 mama/c_cpp/src/c/mama/fieldcache/fieldcacherecord.h

create mode 100644 mama/c_cpp/src/c/mama/fieldcache/fieldcachetypes.h

create mode 100644 mama/c_cpp/src/cpp/fieldcache/MamaFieldCache.cpp

create mode 100644 mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheField.cpp

create mode 100644 mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheFieldTypes.cpp

create mode 100644 mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheRecord.cpp

create mode 100644 mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCache.h

create mode 100644 mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheField.h

create mode 100644 mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheFieldTypes.h

create mode 100644 mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheRecord.h

create mode 100644 mama/c_cpp/src/examples/c/mamalistencachedc.c

create mode 100644 mama/c_cpp/src/examples/c/mamalistencachedc.vcproj

create mode 100644 mama/c_cpp/src/examples/c/openmamalistencachedc.vcproj

create mode 100644 mama/c_cpp/src/examples/cpp/mamalistencachedcpp.cpp

create mode 100644 mama/c_cpp/src/examples/cpp/mamalistencachedcpp.vcproj

create mode 100644 mama/c_cpp/src/examples/cpp/openmamalistencachedcpp.vcproj

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/Makefile.am

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/Makefile.sample

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcachefieldtest.cpp

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcacheiteratortest.cpp

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcachelisttest.cpp

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcachemaptest.cpp

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcacherecordtest.cpp

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcachetest.cpp

create mode 100644 mama/c_cpp/src/gunittest/c/fieldcache/fieldcachevectortest.cpp

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/Makefile.am

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/Makefile.sample

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/MamaFieldCacheFieldTest.cpp

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/MamaFieldCacheFieldTypesTest.cpp

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/MamaFieldCacheIteratorTest.cpp

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/MamaFieldCacheRecordTest.cpp

create mode 100644 mama/c_cpp/src/gunittest/cpp/fieldcache/MamaFieldCacheTest.cpp

 

diff --git a/mama/c_cpp/configure.ac b/mama/c_cpp/configure.ac

index 824ecc5..1741472 100644

--- a/mama/c_cpp/configure.ac

+++ b/mama/c_cpp/configure.ac

@@ -422,8 +422,10 @@ AC_OUTPUT([Makefile \

     src/gunittest/c/Makefile \

     src/gunittest/c/payload/Makefile \

     src/gunittest/c/middleware/Makefile \

+    src/gunittest/c/fieldcache/Makefile \

     src/gunittest/c/mamamsg/Makefile \

     src/gunittest/c/mamaprice/Makefile \

     src/gunittest/c/mamadatetime/Makefile \

     src/gunittest/cpp/Makefile \

+    src/gunittest/cpp/fieldcache/Makefile \

     ])

diff --git a/mama/c_cpp/src/c/Makefile.am b/mama/c_cpp/src/c/Makefile.am

index 64ebac0..ab8b9ca 100644

--- a/mama/c_cpp/src/c/Makefile.am

+++ b/mama/c_cpp/src/c/Makefile.am

@@ -84,7 +84,12 @@ nobase_include_HEADERS  = \

               mama/transport.h \

               mama/types.h \

     mama/conflation/connection.h \

-              mama/version.h

+             mama/version.h \

+    mama/fieldcache/fieldcache.h \

+    mama/fieldcache/fieldcachefield.h \

+    mama/fieldcache/fieldcacheiterator.h \

+    mama/fieldcache/fieldcacherecord.h \

+    mama/fieldcache/fieldcachetypes.h

 

    

 CFLAGS   += -I${srcdir}/../../../../common/c_cpp/src/c

@@ -173,7 +178,19 @@ libmama_la_SOURCES = \

     playback/playbackcapture.c \

     conflation/connection.c \

     conflation/serverconnection.c \

-    conflation/manager.c

+    conflation/manager.c \

+    fieldcache/fieldcachevector.c \

+    fieldcache/fieldcachelist.c \

+    fieldcache/fieldcachemap.c \

+    fieldcache/fieldcachemaparray.c \

+    fieldcache/fieldcachemapbinary.c \

+    fieldcache/fieldcachemapmonitor.c \

+    fieldcache/fieldcacheiterator.c \

+    fieldcache/fieldcachefieldimpl.c \

+    fieldcache/fieldcachefield.c \

+    fieldcache/fieldcacherecord.c \

+    fieldcache/fieldcacheimpl.c \

+    fieldcache/fieldcache.c

        

 nodist_libmama_la_SOURCES = \

               @builddir@/version.c

diff --git a/mama/c_cpp/src/c/SConscript b/mama/c_cpp/src/c/SConscript

index 801944d..5f949c7 100644

--- a/mama/c_cpp/src/c/SConscript

+++ b/mama/c_cpp/src/c/SConscript

@@ -60,6 +60,14 @@ InstConflInclude = Split("""

     mama/conflation/connection.h

 """)

 

+InstFieldCacheInclude = Split("""

+    mama/fieldcache/fieldcache.h

+    mama/fieldcache/fieldcachefield.h

+    mama/fieldcache/fieldcacheiterator.h

+    mama/fieldcache/fieldcacherecord.h

+    mama/fieldcache/fieldcachetypes.h

+""")

+

includePath = []

includePath.append('#mama/c_cpp/src/c')

includePath.append('$prefix/include')

@@ -135,6 +143,18 @@ libmama_sources = \

     conflation/connection.c

    conflation/serverconnection.c

     conflation/manager.c

+    fieldcache/fieldcache.c

+    fieldcache/fieldcachefieldimpl.c

+    fieldcache/fieldcacheiterator.c

+    fieldcache/fieldcachemaparray.c

+    fieldcache/fieldcachemap.c

+    fieldcache/fieldcacherecord.c

+    fieldcache/fieldcachefield.c

+    fieldcache/fieldcacheimpl.c

+    fieldcache/fieldcachelist.c

+    fieldcache/fieldcachemapbinary.c

+    fieldcache/fieldcachemapmonitor.c

+    fieldcache/fieldcachevector.c

""")

 

 objects = []

@@ -160,6 +180,8 @@ Alias('install', env.Install('$libdir', lib))

Alias('install', env.Install('$prefix/include/mama', InstMamaInclude))

Alias('install', env.Install('$prefix/include/mama/conflation',

       InstConflInclude))

+Alias('install', env.Install('$prefix/include/mama/fieldcache',

+      InstFieldCacheInclude))

 

 env.SConscript('bridge/SConscript', 'env')

env.SConscript('payload/SConscript', 'env')

diff --git a/mama/c_cpp/src/c/SConscript.win b/mama/c_cpp/src/c/SConscript.win

index 7541c9a..cbae5b1 100644

--- a/mama/c_cpp/src/c/SConscript.win

+++ b/mama/c_cpp/src/c/SConscript.win

@@ -74,10 +74,23 @@ conflation/serverconnection.c

playback/playbackcapture.c

playback/playbackFileParser.c

playback/playbackpublisher.c

+fieldcache/fieldcachefield.c

+fieldcache/fieldcachemapbinary.c

+fieldcache/fieldcachemaparray.c

+fieldcache/fieldcachemapmonitor.c

+fieldcache/fieldcacheimpl.c

+fieldcache/fieldcachemap.c

+fieldcache/fieldcacheiterator.c

+fieldcache/fieldcachevector.c

+fieldcache/fieldcachefieldimpl.c

+fieldcache/fieldcache.c

+fieldcache/fieldcachelist.c

+fieldcache/fieldcacherecord.c

""")

 

 headers = Glob("mama/*.h")

playbackHeaders = Glob("mama/playback/*.h")

+fieldcacheHeaders = Glob("mama/fieldcache/*.h")

 

 if env['entitled'] == True:

     EntLIB = posixpath.join( env['entitle_home'], 'lib/%s/liboeac%s.lib' % ( env['build'],env['suffix']))

@@ -94,3 +107,4 @@ if ( env['build'] == 'dynamic' or len(env['buildtype']) == 1):

     env.Install('$prefix/include/mama',headers)

     env.Install('$prefix/include/mama/conflation','mama/conflation/connection.h')

     env.Install('$prefix/include/mama/playback', playbackHeaders)

+    env.Install('$prefix/include/mama/fieldcache', fieldcacheHeaders)

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcache.c b/mama/c_cpp/src/c/fieldcache/fieldcache.c

new file mode 100644

index 0000000..9ba6418

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcache.c

@@ -0,0 +1,552 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcache.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcacheimpl.h"

+#include "fieldcachefieldimpl.h"

+#include "fieldcacherecordimpl.h"

+#include <mamainternal.h>

+#include <mama/fieldcache/fieldcache.h>

+#include <mama/fieldcache/fieldcachefield.h>

+#include <mama/fieldcache/fieldcacheiterator.h>

+#include <mama/fieldcache/fieldcacherecord.h>

+#include <mama/price.h>

+#include <mama/datetime.h>

+#include <mama/msg.h>

+#include <stdlib.h>

+#include <assert.h>

+#include <stdio.h>

+

+#define FIELD_CACHE_LOCK(cache) if (cache->mUseLock) { wlock_lock(cache->mLock); }

+#define FIELD_CACHE_UNLOCK(cache) if (cache->mUseLock) { wlock_unlock(cache->mLock); }

+

+mama_status mamaFieldCache_create(mamaFieldCache* fieldCache)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaFieldCache localCache = NULL;

+    const char * propstring = NULL;

+

+    if(!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+   

+    localCache = (mamaFieldCache)calloc(1, sizeof(mamaFieldCacheImpl));

+    if(!localCache)

+    {

+        return MAMA_STATUS_NOMEM;

+    }

+   

+    localCache->mLock = wlock_create();

+

+    propstring = properties_Get (mamaInternal_getProperties (), "mama.fieldcache.type");

+    if (propstring != NULL && strcmp (propstring, "payload") == 0)

+    {

+        localCache->mCachePayload = 1;

+    }

+    else

+    {

+        ret = mamaFieldCacheMap_create(&localCache->mMap);

+        if(ret != MAMA_STATUS_OK)

+        {

+            mamaFieldCache_destroy(localCache);

+            return ret;

+        }

+

+        mamaFieldCacheList_create(&localCache->mAlwaysPublishFields);

+        mamaFieldCacheList_create(&localCache->mModifiedFields);

+

+        mamaDateTime_create(&localCache->mReusableDateTime);

+        mamaPrice_create(&localCache->mReusablePrice);

+        localCache->mTrackModified = 1;

+    }

+

+    /* Write back the field cache pointer */

+    *fieldCache = localCache;

+

+    return ret;

+}

+

+mama_status mamaFieldCache_destroy(mamaFieldCache fieldCache)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+

+    if (fieldCache->mCachePayload)

+    {

+        if (fieldCache->mCacheMsg)

+        {

+            mamaMsg_destroy(fieldCache->mCacheMsg);

+        }

+    }

+    else

+    {

+        mamaFieldCacheMap_destroy(fieldCache->mMap);

+        if (fieldCache->mIterator)

+        {

+            mamaMsgIterator_destroy(fieldCache->mIterator);

+        }

+        mamaFieldCacheList_destroy(fieldCache->mAlwaysPublishFields);

+        mamaFieldCacheList_destroy(fieldCache->mModifiedFields);

+

+        mamaDateTime_destroy(fieldCache->mReusableDateTime);

+        mamaPrice_destroy(fieldCache->mReusablePrice);

+    }

+

+    wlock_destroy(fieldCache->mLock);

+

+    free(fieldCache);

+

+    return MAMA_STATUS_OK;

+}

+

+

+mama_status mamaFieldCache_clear(mamaFieldCache fieldCache)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    FIELD_CACHE_LOCK(fieldCache);

+    /* TODO: should we implement this function using mamaMsg methods??? */

+    if (fieldCache->mCachePayload)

+    {

+         if (fieldCache->mCacheMsg)

+             mamaMsg_clear(fieldCache->mCacheMsg);

+    }

+    else

+    {

+        mamaFieldCacheMap_clear(fieldCache->mMap);

+        mamaFieldCacheList_clear(fieldCache->mAlwaysPublishFields);

+        mamaFieldCacheList_clear(fieldCache->mModifiedFields);

+        fieldCache->mSize = 0;

+    }

+    FIELD_CACHE_UNLOCK(fieldCache);

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_getSize(mamaFieldCache fieldCache, mama_size_t* size)

+{

+    if (!fieldCache || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *size = fieldCache->mSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_find(

+        mamaFieldCache fieldCache,

+        mama_fid_t fid,

+        const char* name,

+        mamaFieldCacheField* field)

+{

+    mama_status ret;

+    if (!fieldCache || !field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (fieldCache->mCachePayload)

+    {

+        return MAMA_STATUS_NOT_IMPLEMENTED;

+    }

+    FIELD_CACHE_LOCK(fieldCache);

+    ret = mamaFieldCacheMap_find(fieldCache->mMap,

+                                 fid,

+                                 MAMA_FIELD_TYPE_UNKNOWN,

+                                 name,

+                                 field);

+    FIELD_CACHE_UNLOCK(fieldCache);

+    return ret;

+}

+

+mama_status mamaFieldCache_findOrAdd(

+        mamaFieldCache fieldCache,

+        mama_fid_t fid,

+        mamaFieldType type,

+        const char* name,

+        mamaFieldCacheField* field,

+        mama_bool_t* existing)

+{

+    mama_status ret = MAMA_STATUS_OK;

+

+    if (!fieldCache || !field || !existing)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (fieldCache->mCachePayload)

+    {

+        return MAMA_STATUS_NOT_IMPLEMENTED;

+    }

+

+    FIELD_CACHE_LOCK(fieldCache);

+    ret = mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, field);

+    if (ret == MAMA_STATUS_OK && *field)

+    {

+        *existing = 1;

+        FIELD_CACHE_UNLOCK(fieldCache);

+        return ret;

+    }

+    *existing = 0;

+    ret = mamaFieldCacheField_create(field, fid, type, name);

+    if (ret != MAMA_STATUS_OK)

+    {

+        FIELD_CACHE_UNLOCK(fieldCache);

+        return ret;

+    }

+    ret = mamaFieldCacheMap_add(fieldCache->mMap, *field);

+    if (ret == MAMA_STATUS_OK)

+    {

+        fieldCache->mSize++;

+    }

+    FIELD_CACHE_UNLOCK(fieldCache);

+    return ret;

+}

+

+/* There is no check that field is actually present in the field cache */

+mama_status mamaFieldCache_setModified(mamaFieldCache fieldCache,

+                                       mamaFieldCacheField field)

+{

+    if (!fieldCache || !field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (fieldCache->mTrackModified == 0 || field->mIsModified)

+    {

+        return MAMA_STATUS_OK;

+    }

+

+    field->mIsModified = 1;

+    mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)field);

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_applyField(mamaFieldCache fieldCache,

+                                      const mamaFieldCacheField field)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    if (!fieldCache || !field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (fieldCache->mCachePayload)

+    {

+        return MAMA_STATUS_NOT_IMPLEMENTED;

+    }

+    FIELD_CACHE_LOCK(fieldCache);

+    ret = mamaFieldCache_updateCacheFromField(fieldCache, field);

+    FIELD_CACHE_UNLOCK(fieldCache);

+    return ret;

+}

+

+mama_status mamaFieldCache_applyMessage(

+        mamaFieldCache fieldCache,

+        const mamaMsg message,

+        mamaDictionary dictionary)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaMsgField nextField = NULL;

+

+    if (!fieldCache || !message)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+

+    if (fieldCache->mCachePayload)

+    {

+        if (!fieldCache->mCacheMsg)

+        {

+                                             ret=mamaMsg_copy(message, &fieldCache->mCacheMsg);

+        }

+                             else

+                             {

+             ret=mamaMsg_applyMsg(fieldCache->mCacheMsg, message);

+                            

+                             }             

+        return ret;

+    }

+

+    if(!fieldCache->mIterator)

+    {

+        ret = mamaMsgIterator_create(&fieldCache->mIterator, dictionary);

+        if(ret != MAMA_STATUS_OK)

+        {

+            return ret;

+        }

+    }

+

+    ret = mamaMsgIterator_associate(fieldCache->mIterator, message);

+    if(ret != MAMA_STATUS_OK)

+    {

+        return ret;

+    }

+    FIELD_CACHE_LOCK(fieldCache);

+    nextField = mamaMsgIterator_next(fieldCache->mIterator);

+    while(nextField && ret == MAMA_STATUS_OK)

+    {

+        ret = mamaFieldCache_updateCacheFromMsgField(fieldCache, nextField);

+        nextField = mamaMsgIterator_next(fieldCache->mIterator);

+    }

+    FIELD_CACHE_UNLOCK(fieldCache);

+

+    return ret;

+}

+

+mama_status mamaFieldCache_applyRecord(

+        mamaFieldCache fieldCache,

+        const mamaFieldCacheRecord record)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaFieldCacheField newField;

+    mama_size_t size = 0;

+    mama_size_t counter;

+

+    if (!fieldCache || !record)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (fieldCache->mCachePayload)

+    {

+        return MAMA_STATUS_NOT_IMPLEMENTED;

+    }

+

+    mamaFieldCacheRecord_getSize(record, &size);

+    for(counter = 0; counter < size; counter++)

+    {

+        /* Reset output parameter, because if it is not found it is not overwritten */

+        newField = NULL;

+        mamaFieldCacheRecord_getField(record, counter, &newField);

+        if (newField)

+        {

+            ret = mamaFieldCache_updateCacheFromField(fieldCache, newField);

+        }

+    }

+

+    return ret;

+}

+

+mama_status mamaFieldCache_getFullMessage(

+        mamaFieldCache fieldCache,

+        mamaMsg message)

+{

+    mama_bool_t publish;

+    mamaFieldCacheField field = NULL;

+    mamaFieldCacheIterator iterator = NULL;

+    mama_size_t numFields = 0;

+

+    if (!fieldCache || !message)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+  

+    if (fieldCache->mCacheMsg)

+    {

+        return mamaMsg_copy (fieldCache->mCacheMsg, &message);

+    }

+

+    mamaMsg_getNumFields(message, &numFields);

+    mamaFieldCacheIterator_create(&iterator, fieldCache);   

+    FIELD_CACHE_LOCK(fieldCache);

+    while (mamaFieldCacheIterator_hasNext(iterator))

+    {

+        field = mamaFieldCacheIterator_next(iterator);

+        mamaFieldCacheField_getPublish(field, &publish);

+        if (publish)

+        {

+            mamaFieldCache_updateMsgField(fieldCache, field, message, numFields);

+        }

+    }

+    FIELD_CACHE_UNLOCK(fieldCache);

+    mamaFieldCacheIterator_destroy(iterator);

+   

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_getDeltaMessage(

+        mamaFieldCache fieldCache,

+        mamaMsg message)

+{

+    mamaFieldCacheField field = NULL;

+    mama_size_t numFields = 0;

+    mama_size_t numMsgFields = 0;

+    mama_size_t i;

+

+    if (!fieldCache || !message)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (!fieldCache->mTrackModified)

+    {

+        return mamaFieldCache_getFullMessage(fieldCache, message);

+    }

+

+    mamaMsg_getNumFields(message, &numMsgFields);

+

+    FIELD_CACHE_LOCK(fieldCache);

+    mamaFieldCacheList_getSize(fieldCache->mAlwaysPublishFields, &numFields);

+    for (i = 0; i < numFields; ++i)

+    {

+        void* tmpField = NULL;

+        mamaFieldCacheList_get(fieldCache->mAlwaysPublishFields, i, &tmpField);

+        assert(tmpField);

+        field = (mamaFieldCacheField)tmpField;

+        mamaFieldCache_updateMsgField(fieldCache, field, message, numMsgFields);

+        field->mIsModified = 0;

+    }

+

+    mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &numFields);

+    for (i = 0; i < numFields; ++i)

+    {

+        void* tmpField = NULL;

+        mamaFieldCacheList_get(fieldCache->mModifiedFields, i, &tmpField);

+        assert(tmpField);

+        field = (mamaFieldCacheField)tmpField;

+        mamaFieldCache_updateMsgField(fieldCache, field, message, numMsgFields);

+        field->mIsModified = 0;

+    }

+    mamaFieldCacheList_clear(fieldCache->mModifiedFields);

+    FIELD_CACHE_UNLOCK(fieldCache);

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCache_clearModifiedFields(mamaFieldCache fieldCache)

+{

+    mamaFieldCacheField field = NULL;

+    mama_size_t numFields = 0;

+    mama_size_t i;

+

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (!fieldCache->mTrackModified)

+    {

+        return MAMA_STATUS_OK;

+    }

+

+    mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &numFields);

+    for (i = 0; i < numFields; ++i)

+    {

+        void* tmpField = NULL;

+        mamaFieldCacheList_get(fieldCache->mModifiedFields, i, &tmpField);

+        assert(tmpField);

+        field = (mamaFieldCacheField)tmpField;

+        field->mIsModified = 0;

+    }

+    mamaFieldCacheList_clear(fieldCache->mModifiedFields);

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_setTrackModified(

+    mamaFieldCache fieldCache,

+    mama_bool_t trackModified)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+             if (!fieldCache->mCachePayload)

+    {

+             fieldCache->mTrackModified = trackModified;

+    }

+             return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_getTrackModified(

+    mamaFieldCache fieldCache,

+    mama_bool_t* trackModified)

+{

+    if (!fieldCache || !trackModified)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *trackModified = fieldCache->mTrackModified;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_setUseFieldNames(

+        mamaFieldCache fieldCache,

+        mama_bool_t useFieldNames)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    fieldCache->mUseFieldNames = useFieldNames;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_getUseFieldNames(

+        mamaFieldCache fieldCache,

+        mama_bool_t* useFieldNames)

+{

+    if (!fieldCache || !useFieldNames)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *useFieldNames = fieldCache->mUseFieldNames;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_setUseLock(mamaFieldCache fieldCache, mama_bool_t enable)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    fieldCache->mUseLock = enable;

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCache_getUseLock(mamaFieldCache fieldCache, mama_bool_t* lockEnabled)

+{

+    if (!fieldCache || !lockEnabled)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *lockEnabled = fieldCache->mUseLock;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_lock(mamaFieldCache fieldCache)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    FIELD_CACHE_LOCK(fieldCache);

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCache_unlock(mamaFieldCache fieldCache)

+{

+    if (!fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    FIELD_CACHE_UNLOCK(fieldCache);

+    return MAMA_STATUS_OK;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachefield.c b/mama/c_cpp/src/c/fieldcache/fieldcachefield.c

new file mode 100644

index 0000000..7eecda0

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachefield.c

@@ -0,0 +1,1507 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachefield.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachefieldimpl.h"

+#include "fieldcachevector.h"

+#include <mama/fieldcache/fieldcachefield.h>

+#include <mama/price.h>

+#include <mama/datetime.h>

+#include <stdio.h>

+

+mama_bool_t mamaFieldCacheField_isSupported(mamaFieldType type)

+{

+    switch (type)

+    {

+        case MAMA_FIELD_TYPE_MSG:

+        case MAMA_FIELD_TYPE_VECTOR_MSG:

+        case MAMA_FIELD_TYPE_UNKNOWN:

+        case MAMA_FIELD_TYPE_COLLECTION:

+        case MAMA_FIELD_TYPE_OPAQUE:

+            return 0;

+        default:

+            return 1;

+    }

+}

+

+mama_status mamaFieldCacheField_create(mamaFieldCacheField* field,

+                                       mama_fid_t fid,

+                                       mamaFieldType type,

+                                       const char* name)

+{

+    mamaFieldCacheField localField = NULL;

+

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+

+    if (!mamaFieldCacheField_isSupported(type))

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    localField = (mamaFieldCacheField)calloc(1, sizeof(mamaFieldCacheFieldImpl));

+    if (!localField)

+    {

+        return MAMA_STATUS_NOMEM;

+    }

+

+    localField->mFid = fid;

+    localField->mType = type;

+    if (name)

+    {

+        localField->mName = strdup(name);

+    }

+    localField->mPublish = 1;

+    localField->mCheckModified = 1;

+

+    *field = localField;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_destroy(mamaFieldCacheField field)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+

+    if (field->mName)

+    {

+        free((void*)field->mName);

+    }

+

+    if (field->mDataSize)

+    {

+        free(field->mData.data);

+    }

+    else

+    {

+        switch (field->mType)

+        {

+        case MAMA_FIELD_TYPE_PRICE:

+            mamaPrice_destroy((mamaPrice)field->mData.data);

+            break;

+        case MAMA_FIELD_TYPE_TIME:

+            mamaDateTime_destroy((mamaDateTime)field->mData.data);

+            break;

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+            if (field->mData.data)

+            {

+                mamaFieldCacheVector_free((mamaFieldCacheVector)field->mData.data);

+                mamaFieldCacheVector_destroy((mamaFieldCacheVector)field->mData.data);

+            }

+            break;

+        case MAMA_FIELD_TYPE_VECTOR_PRICE:

+            if (field->mData.data)

+            {

+                mamaFieldCacheField_destroyPriceVector(

+                        (mamaFieldCacheVector)field->mData.data);

+            }

+            break;

+        case MAMA_FIELD_TYPE_VECTOR_TIME:

+            if (field->mData.data)

+            {

+                mamaFieldCacheField_destroyDateTimeVector(

+                        (mamaFieldCacheVector)field->mData.data);

+            }

+            break;

+        default: /* something is wrong here */

+            break;

+        }

+    }

+    free(field);

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheField_copy(const mamaFieldCacheField field, mamaFieldCacheField copy)

+{

+    if (!field || !copy)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field == copy)

+    {

+        return MAMA_STATUS_OK;

+    }

+    if (field->mFid != copy->mFid || field->mType != copy->mType)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    copy->mIsModified = field->mIsModified;

+    copy->mPublish = field->mPublish;

+    copy->mCheckModified = field->mCheckModified;

+    copy->mDescriptor = field->mDescriptor;

+    if (field->mName)

+    {

+        if (copy->mName)

+        {

+            free((void*)copy->mName);

+        }

+        copy->mName = strdup(field->mName);

+    }

+    switch (field->mType)

+    {

+        case MAMA_FIELD_TYPE_BOOL:

+        {

+            mama_bool_t result;

+            mamaFieldCacheField_getBool(field, &result);

+            mamaFieldCacheField_setBool(copy, result);

+            break;

+        }

+        case MAMA_FIELD_TYPE_CHAR:

+        {

+            char value;

+            mamaFieldCacheField_getChar(field, &value);

+            mamaFieldCacheField_setChar(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I8:

+        {

+            mama_i8_t value;

+            mamaFieldCacheField_getI8(field, &value);

+            mamaFieldCacheField_setI8(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U8:

+        {

+            mama_u8_t value;

+            mamaFieldCacheField_getU8(field, &value);

+            mamaFieldCacheField_setU8(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I16:

+        {

+            mama_i16_t value;

+            mamaFieldCacheField_getI16(field, &value);

+            mamaFieldCacheField_setI16(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U16:

+        {

+            mama_u16_t value;

+            mamaFieldCacheField_getU16(field, &value);

+            mamaFieldCacheField_setU16(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I32:

+        {

+            mama_i32_t value;

+            mamaFieldCacheField_getI32(field, &value);

+            mamaFieldCacheField_setI32(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U32:

+        {

+            mama_u32_t value;

+            mamaFieldCacheField_getU32(field, &value);

+            mamaFieldCacheField_setU32(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I64:

+        {

+            mama_i64_t value;

+            mamaFieldCacheField_getI64(field, &value);

+            mamaFieldCacheField_setI64(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U64:

+        {

+            mama_u64_t value;

+            mamaFieldCacheField_getU64(field, &value);

+            mamaFieldCacheField_setU64(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F32:

+        {

+            mama_f32_t value;

+            mamaFieldCacheField_getF32(field, &value);

+            mamaFieldCacheField_setF32(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_QUANTITY:

+        case MAMA_FIELD_TYPE_F64:

+        {

+            mama_f64_t value;

+            mamaFieldCacheField_getF64(field, &value);

+            mamaFieldCacheField_setF64(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_STRING:

+        {

+            const char* value;

+            mama_size_t len;

+            mamaFieldCacheField_getString(field, &value, &len);

+            mamaFieldCacheField_setString(copy, value, len);

+            break;

+        }

+        case MAMA_FIELD_TYPE_PRICE:

+        {

+            mamaPrice value = NULL;

+            const mamaPrice* pvalue = &value;

+            mamaFieldCacheField_getPrice(field, pvalue);

+            mamaFieldCacheField_setPrice(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_TIME:

+        {

+            mamaDateTime value = NULL;

+            const mamaDateTime* pvalue = &value;

+            mamaFieldCacheField_getDateTime(field, pvalue);

+            mamaFieldCacheField_setDateTime(copy, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        {

+            const mama_i8_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getI8Vector(field, &values, &size);

+            mamaFieldCacheField_setI8Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        {

+            const mama_u8_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getU8Vector(field, &values, &size);

+            mamaFieldCacheField_setU8Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        {

+            const mama_i16_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getI16Vector(field, &values, &size);

+            mamaFieldCacheField_setI16Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        {

+            const mama_u16_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getU16Vector(field, &values, &size);

+            mamaFieldCacheField_setU16Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        {

+            const mama_i32_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getI32Vector(field, &values, &size);

+            mamaFieldCacheField_setI32Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        {

+            const mama_u32_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getU32Vector(field, &values, &size);

+            mamaFieldCacheField_setU32Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        {

+            const mama_i64_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getI64Vector(field, &values, &size);

+            mamaFieldCacheField_setI64Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        {

+            const mama_u64_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getU64Vector(field, &values, &size);

+            mamaFieldCacheField_setU64Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F32:

+        {

+            const mama_f32_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getF32Vector(field, &values, &size);

+            mamaFieldCacheField_setF32Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F64:

+        {

+            const mama_f64_t* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getF64Vector(field, &values, &size);

+            mamaFieldCacheField_setF64Vector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+        {

+            const char** values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getStringVector(field, &values, &size);

+            mamaFieldCacheField_setStringVector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_PRICE:

+        {

+            const mamaPrice* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getPriceVector(field, &values, &size);

+            mamaFieldCacheField_setPriceVector(copy, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_TIME:

+        {

+            const mamaDateTime* values = NULL;

+            mama_size_t size;

+            mamaFieldCacheField_getDateTimeVector(field, &values, &size);

+            mamaFieldCacheField_setDateTimeVector(copy, values, size);

+            break;

+        }

+        default:

+            break;

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getFid(mamaFieldCacheField field, mama_fid_t* fid)

+{

+    if (!field || !fid)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *fid = field->mFid;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getType(mamaFieldCacheField field, mamaFieldType* type)

+{

+    if (!field || !type)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *type = field->mType;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getName(mamaFieldCacheField field, const char** name)

+{

+    if (!field || !name)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mName)

+    {

+        *name = field->mName;

+    }

+    else if (field->mDescriptor)

+    {

+        *name = mamaFieldDescriptor_getName(field->mDescriptor);

+    }

+    else

+    {

+        *name = NULL;

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setDescriptor(mamaFieldCacheField field,

+                                              const mamaFieldDescriptor desc)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    field->mDescriptor = desc;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getDescriptor(mamaFieldCacheField field,

+                                              const mamaFieldDescriptor* desc)

+{

+    if (!field || !desc)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *(mamaFieldDescriptor*)desc = field->mDescriptor;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_isModified(mamaFieldCacheField field,

+                                           mama_bool_t* modified)

+{

+    if (!field || !modified)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *modified = field->mIsModified;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setPublish(mamaFieldCacheField field,

+                                           mama_bool_t publish)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    field->mPublish = publish;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getPublish(mamaFieldCacheField field,

+                                           mama_bool_t* publish)

+{

+    if (!field || !publish)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *publish = field->mPublish;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setCheckModified(mamaFieldCacheField field,

+                                                 mama_bool_t check)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    field->mCheckModified = check;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getCheckModified(mamaFieldCacheField field,

+                                                 mama_bool_t* check)

+{

+    if (!field || !check)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *check = field->mCheckModified;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getBool(const mamaFieldCacheField field,

+                                        mama_bool_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_BOOL)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.abool;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getChar(const mamaFieldCacheField field,

+                                        char* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_CHAR)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.chr;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI8(const mamaFieldCacheField field,

+                                      mama_i8_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.i8;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU8(const mamaFieldCacheField field,

+                                      mama_u8_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.u8;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI16(const mamaFieldCacheField field,

+                                       mama_i16_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.i16;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU16(const mamaFieldCacheField field,

+                                       mama_u16_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.u16;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI32(const mamaFieldCacheField field,

+                                       mama_i32_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.i32;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU32(const mamaFieldCacheField field,

+                                       mama_u32_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.u32;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI64(const mamaFieldCacheField field,

+                                       mama_i64_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.i64;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU64(const mamaFieldCacheField field,

+                                       mama_u64_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.u64;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getF32(const mamaFieldCacheField field,

+                                       mama_f32_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_F32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.f32;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getF64(const mamaFieldCacheField field,

+                                       mama_f64_t* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_F64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.f64;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getString(const mamaFieldCacheField field,

+                                          const char** result,

+                                          mama_size_t* len)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_STRING)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *result = field->mData.str; /* NOT COPYING */

+    *len = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getPrice(const mamaFieldCacheField field,

+                                         const mamaPrice* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_PRICE)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *(mamaPrice*)result = (mamaPrice)field->mData.data; /* NOT COPYING */

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getDateTime(const mamaFieldCacheField field,

+                                            const mamaDateTime* result)

+{

+    if (!field || !result)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_TIME)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *(mamaDateTime*)result = (mamaDateTime)field->mData.data; /* NOT COPYING */

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI8Vector(const mamaFieldCacheField field,

+                                            const mama_i8_t** values,

+                                            mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_i8_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU8Vector(const mamaFieldCacheField field,

+                                            const mama_u8_t** values,

+                                            mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_u8_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI16Vector(const mamaFieldCacheField field,

+                                             const mama_i16_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_i16_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU16Vector(const mamaFieldCacheField field,

+                                             const mama_u16_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_u16_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI32Vector(const mamaFieldCacheField field,

+                                             const mama_i32_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_i32_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU32Vector(const mamaFieldCacheField field,

+                                             const mama_u32_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_u32_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getI64Vector(const mamaFieldCacheField field,

+                                             const mama_i64_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_i64_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getU64Vector(const mamaFieldCacheField field,

+                                             const mama_u64_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_u64_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getF32Vector(const mamaFieldCacheField field,

+                                             const mama_f32_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_F32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_f32_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getF64Vector(const mamaFieldCacheField field,

+                                             const mama_f64_t** values,

+                                             mama_size_t* size)

+{

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_F64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *values = (mama_f64_t*)field->mData.data; /* NOT COPYING */

+    *size = field->mVectorSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getStringVector(const mamaFieldCacheField field,

+                                                const char*** values,

+                                                mama_size_t* size)

+{

+    mamaFieldCacheVector vector = NULL;

+

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_STRING)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    vector = (mamaFieldCacheVector)field->mData.data;

+    if (vector)

+    {

+        *values = (const char**)vector->mData; /* NOT COPYING */

+        *size = field->mVectorSize;

+    }

+    else

+    {

+        *values = NULL;

+        *size = 0;

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getPriceVector(const mamaFieldCacheField field,

+                                               const mamaPrice** values,

+                                               mama_size_t* size)

+{

+    mamaFieldCacheVector vector = NULL;

+

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_PRICE)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    vector = (mamaFieldCacheVector)field->mData.data;

+    if (vector)

+    {

+        *values = (mamaPrice*)vector->mData; /* NOT COPYING */

+        *size = field->mVectorSize;

+    }

+    else

+    {

+        *values = NULL;

+        *size = 0;

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_getDateTimeVector(const mamaFieldCacheField field,

+                                                  const mamaDateTime** values,

+                                                  mama_size_t* size)

+{

+    mamaFieldCacheVector vector = NULL;

+

+    if (!field || !values || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_TIME)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    vector = (mamaFieldCacheVector)field->mData.data;

+    if (vector)

+    {

+        *values = (mamaDateTime*)vector->mData; /* NOT COPYING */

+        *size = field->mVectorSize;

+    }

+    else

+    {

+        *values = NULL;

+        *size = 0;

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setBool(mamaFieldCacheField field, mama_bool_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_BOOL)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.abool = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setChar(mamaFieldCacheField field, char value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_CHAR)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.chr = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setI8(mamaFieldCacheField field, mama_i8_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.i8 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setU8(mamaFieldCacheField field, mama_u8_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.u8 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setI16(mamaFieldCacheField field, mama_i16_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.i16 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setU16(mamaFieldCacheField field, mama_u16_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.u16 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setI32(mamaFieldCacheField field, mama_i32_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.i32 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setU32(mamaFieldCacheField field, mama_u32_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.u32 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setI64(mamaFieldCacheField field, mama_i64_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_I64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.i64 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setU64(mamaFieldCacheField field, mama_u64_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_U64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+   field->mData.u64 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setF32(mamaFieldCacheField field, mama_f32_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_F32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.f32 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setF64(mamaFieldCacheField field, mama_f64_t value)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_F64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mData.f64 = value;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setString(const mamaFieldCacheField field,

+                                          const char* value,

+                                          mama_size_t len)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_STRING)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    if (len == 0 && value)

+    {

+        len = strlen(value);

+    }

+    field->mVectorSize = len;

+    return mamaFieldCacheField_setDataValue(

+            field,

+            value,/* Copy also string terminator */

+            value ? len + 1 : 0);

+}

+

+mama_status mamaFieldCacheField_setPrice(const mamaFieldCacheField field,

+                                         const mamaPrice value)

+{

+    mamaPrice price = NULL;

+    void* old = NULL;

+   

+    if (!field || !value)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_PRICE)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    if (!field->mData.data)

+    {

+        mamaPrice_create(&price);

+        mamaFieldCacheField_setDataPointer(field, (void*)price, &old);

+    }

+    mamaPrice_copy((mamaPrice)field->mData.data, value);

+   

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setDateTime(const mamaFieldCacheField field,

+                                            const mamaDateTime value)

+{

+    mamaDateTime dateTime = NULL;

+    void* old = NULL;

+   

+    if (!field || !value)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_TIME)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    if (!field->mData.data)

+    {

+        mamaDateTime_create(&dateTime);

+        mamaFieldCacheField_setDataPointer(field, (void*)dateTime, &old);

+    }

+    mamaDateTime_copy((mamaDateTime)field->mData.data, value);

+   

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setI8Vector(const mamaFieldCacheField field,

+                                            const mama_i8_t* values,

+                                            mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_i8_t));

+}

+

+mama_status mamaFieldCacheField_setU8Vector(const mamaFieldCacheField field,

+                                            const mama_u8_t* values,

+                                            mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U8)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_i8_t));

+}

+

+mama_status mamaFieldCacheField_setI16Vector(const mamaFieldCacheField field,

+                                             const mama_i16_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_i16_t));

+}

+

+mama_status mamaFieldCacheField_setU16Vector(const mamaFieldCacheField field,

+                                             const mama_u16_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U16)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_u16_t));

+}

+

+mama_status mamaFieldCacheField_setI32Vector(const mamaFieldCacheField field,

+                                             const mama_i32_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_i32_t));

+}

+

+mama_status mamaFieldCacheField_setU32Vector(const mamaFieldCacheField field,

+                                             const mama_u32_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_u32_t));

+}

+

+mama_status mamaFieldCacheField_setI64Vector(const mamaFieldCacheField field,

+                                             const mama_i64_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_I64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_i64_t));

+}

+

+mama_status mamaFieldCacheField_setU64Vector(const mamaFieldCacheField field,

+                                             const mama_u64_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_U64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_u64_t));

+}

+

+mama_status mamaFieldCacheField_setF32Vector(const mamaFieldCacheField field,

+                                             const mama_f32_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_F32)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_f32_t));

+}

+

+mama_status mamaFieldCacheField_setF64Vector(const mamaFieldCacheField field,

+                                             const mama_f64_t* values,

+                                             mama_size_t size)

+{

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_F64)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    field->mVectorSize = size;

+    return mamaFieldCacheField_setDataValue(field, values, size * sizeof(mama_f64_t));

+}

+

+mama_status mamaFieldCacheField_setStringVector(const mamaFieldCacheField field,

+                                                const char** values,

+                                                mama_size_t size)

+{

+    mama_size_t counter;

+    mamaFieldCacheVector vector = NULL;

+    void* string = NULL;

+

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_STRING)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    if (!field->mData.data)

+    {

+        mamaFieldCacheVector_create(&vector);

+        field->mData.data = (void*)vector;

+    }

+    mamaFieldCacheVector_grow(field->mData.data, size);

+    for (counter = 0; counter < size; counter++)

+    {

+        mamaFieldCacheVector_get((mamaFieldCacheVector)field->mData.data, counter, &string);

+        if (string)

+        {

+            free(string);

+        }

+        mamaFieldCacheVector_set((mamaFieldCacheVector)field->mData.data,

+                                 counter,

+                                 (void*)strdup(values[counter]));

+    }

+    field->mVectorSize = size;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setPriceVector(const mamaFieldCacheField field,

+                                               const mamaPrice* values,

+                                               mama_size_t size)

+{

+    mama_size_t index;

+    mamaFieldCacheVector vector = NULL;

+    mamaPrice price = NULL;

+

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_PRICE)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    if (!field->mData.data)

+    {

+        mamaFieldCacheVector_create(&vector);

+        field->mData.data = (void*)vector;

+    }

+    mamaFieldCacheVector_grow(field->mData.data, size);

+    for (index = 0; index < size; index++)

+    {

+        mamaFieldCacheVector_get((mamaFieldCacheVector)field->mData.data,

+                                 index,

+                                 (void**)&price);

+        if (!price)

+        {

+            mamaPrice_create(&price);

+        }

+        mamaPrice_copy(price, values[index]);

+        mamaFieldCacheVector_set((mamaFieldCacheVector)field->mData.data,

+                                 index,

+                                 (void*)price);

+

+    }

+    field->mVectorSize = size;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setDateTimeVector(const mamaFieldCacheField field,

+                                                  const mamaDateTime* values,

+                                                  mama_size_t size)

+{

+    mama_size_t index;

+    mamaFieldCacheVector vector = NULL;

+    void* item = NULL;

+    mamaDateTime dateTime = NULL;

+

+    if (!field || !values)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (field->mType != MAMA_FIELD_TYPE_VECTOR_TIME)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    if (!field->mData.data)

+    {

+        mamaFieldCacheVector_create(&vector);

+        field->mData.data = (void*)vector;

+    }

+    mamaFieldCacheVector_grow(field->mData.data, size);

+    for (index = 0; index < size; index++)

+    {

+        mamaFieldCacheVector_get((mamaFieldCacheVector)field->mData.data,

+                                 index,

+                                 &item);

+        dateTime = (mamaDateTime)item;

+        if (!dateTime)

+        {

+            mamaDateTime_create(&dateTime);

+        }

+        mamaDateTime_copy(dateTime, values[index]);

+        mamaFieldCacheVector_set((mamaFieldCacheVector)field->mData.data,

+                                 index,

+                                 (void*)dateTime);

+    }

+    field->mVectorSize = size;

+    return MAMA_STATUS_OK;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.c b/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.c

new file mode 100644

index 0000000..06d02c4

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.c

@@ -0,0 +1,122 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachefieldimpl.h"

+#include <mama/price.h>

+#include <mama/datetime.h>

+#include <string.h> /* For memcpy */

+

+/* Private functions - not exposed through the API interface */

+/*

+mama_status mamaFieldCacheField_getData(

+        const mamaFieldCacheField field,

+        void** data,

+        mama_u32_t* size)

+{

+    if (!field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+   

+    *data = field->mData;

+    *size = field->mDataSize;

+   

+    return MAMA_STATUS_OK;

+}

+*/

+mama_status mamaFieldCacheField_setDataValue(mamaFieldCacheField field,

+                                             const void* data,

+                                             mama_size_t size)

+{

+    if (field->mData.data && field->mDataSize != size)

+    {

+        free(field->mData.data);

+        field->mData.data = NULL;

+        field->mDataSize = 0;

+    }

+    if (data && size)

+    {

+        if (field->mDataSize != size)

+        {

+            field->mData.data = malloc(size);

+            field->mDataSize = size;

+        }

+        if (field->mData.data)

+        {

+            memcpy(field->mData.data, data, size);

+        }

+    }

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheField_setDataPointer(mamaFieldCacheField field,

+                                               void* data,

+                                               void** old)

+{

+    if (field->mData.data)

+    {

+        *old = field->mData.data;

+        field->mData.data = NULL;

+        field->mDataSize = 0;

+    }

+    if (data)

+    {

+        field->mData.data = data;

+        field->mDataSize = 0;

+    }

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheField_destroyPriceVector(mamaFieldCacheVector priceVector)

+{

+    mama_size_t i;

+    mama_size_t size = 0;

+    void* price = NULL;

+

+    mamaFieldCacheVector_getSize(priceVector, &size);

+    for (i = 0; i < size; i++)

+    {

+        mamaFieldCacheVector_get(priceVector, i, &price);

+        mamaPrice_destroy((mamaPrice)price);

+    }

+    mamaFieldCacheVector_destroy(priceVector);

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheField_destroyDateTimeVector(mamaFieldCacheVector dateTimeVector)

+{

+    mama_size_t i;

+    mama_size_t size = 0;

+    void* dateTime = NULL;

+   

+    mamaFieldCacheVector_getSize(dateTimeVector, &size);

+    for (i = 0; i < size; i++)

+    {

+        mamaFieldCacheVector_get(dateTimeVector, i, &dateTime);

+        mamaDateTime_destroy((mamaDateTime)dateTime);

+    }

+    mamaFieldCacheVector_destroy(dateTimeVector);

+    return MAMA_STATUS_OK;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.h b/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.h

new file mode 100644

index 0000000..c75c51a

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.h

@@ -0,0 +1,138 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachefieldimpl.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheFieldImplH__

+#define MamaFieldCacheFieldImplH__

+

+#include <mama/config.h>

+#include <mama/fielddesc.h>

+#include <mama/types.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+#include "fieldcachevector.h"

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+    /* This structure describes a field that is held in the field cache, it is used

+     * when invoking ultraFast calls on the cache to provide direct read only access

+     * to field data.

+     */

+

+typedef union cacheData_

+{

+    mama_i8_t      i8;

+    mama_u8_t      u8;

+    mama_i16_t     i16;

+    mama_u16_t     u16;

+    mama_i32_t     i32;

+    mama_u32_t     u32;

+    mama_i64_t     i64;

+    mama_u64_t     u64;

+    mama_f32_t     f32;

+    mama_f64_t     f64;

+    mama_bool_t    abool;

+    char           chr;

+    char*          str;

+    void*          data;

+} cacheData;

+

+typedef struct mamaFieldCacheFieldImpl_

+{

+    /* DO NOT CHANGE THE ORDER - IT CAN BREAK THE MEMORY ALIGNMENT */

+

+    /* Field identification */

+    mamaFieldType mType;  /* 4 bytes */

+    mama_fid_t mFid;      /* 2 bytes */

+

+    /* This flag specifies if the field must never be published (0) or can be

+     * published (1)

+     */   

+    mama_bool_t mPublish; /* 1 byte */

+   

+    /* This flag specifies if the field should be checked for modifications (1)

+     * to decide if it must be published

+     */

+    mama_bool_t mCheckModified; /* 1 byte */

+

+    /* This is a pointer to the actual field data */

+    cacheData  mData;

+

+    /* This is the size of the memory allocated for the data */

+    mama_size_t mDataSize;

+

+    /* This is only used for a vector data type and will contain the number of

+     * elements in the vector. For any other type this value will be 0.

+     * If the type is an opaque then it will contain the number of bytes.

+     */

+    mama_size_t mVectorSize;

+   

+    /* Pointer to a field descriptor - NO COPY */

+    mamaFieldDescriptor mDescriptor;

+

+    /* Explicit field name - overrides the field descriptor name */

+    const char* mName;

+   

+    /* The current modification state of the field. */

+    mama_bool_t mIsModified; /* 1 byte */

+} mamaFieldCacheFieldImpl;

+

+/* Get the pointer to the internal data and the size of the memory allocated */

+/*

+mama_status

+mamaFieldCacheField_getData(

+    const mamaFieldCacheField field,

+    void** data,

+    mama_u32_t* size);

+*/

+/* Copy size byte starting at pointer data to field to the internal field data.

+ * New memory is allocated with malloc and old one is freed with free (if needed).

+ */

+mama_status

+mamaFieldCacheField_setDataValue(

+    mamaFieldCacheField field,

+    const void* data,

+    mama_size_t size);

+

+/* Copy pointer data to internal data pointer in field.

+ * Returns a pointer to the old data pointer so that old data can be destroyed

+ * and freed.

+ */

+mama_status

+mamaFieldCacheField_setDataPointer(mamaFieldCacheField field,

+                                   void* data,

+                                   void** old);

+

+/* Price vector type requires a special function to be destroyed and freed.

+ */

+mama_status

+mamaFieldCacheField_destroyPriceVector(mamaFieldCacheVector priceVector);

+

+/* DateTime vector type requires a special function to be destroyed and freed.

+ */

+mama_status

+mamaFieldCacheField_destroyDateTimeVector(mamaFieldCacheVector dateTimeVector);

+

+#if defined(__cplusplus)

+}

+#endif

+

+#endif                /* MamaFieldCacheFieldImplH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.c b/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.c

new file mode 100644

index 0000000..27630a7

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.c

@@ -0,0 +1,687 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcacheimpl.h"

+#include "fieldcachefieldimpl.h"

+#include <mama/fieldcache/fieldcachefield.h>

+#include <mama/msg.h>

+#include <mama/msgfield.h>

+

+mama_status mamaFieldCache_updateCacheFromMsgField(mamaFieldCache fieldCache,

+                                                   const mamaMsgField messageField)

+{

+    mama_status ret;

+    mama_fid_t fid;

+    mamaFieldType type = MAMA_FIELD_TYPE_UNKNOWN;

+    const char* name = NULL;

+    mamaFieldDescriptor descriptor = NULL;

+    mamaFieldCacheField field = NULL;

+

+    ret = mamaMsgField_getFid(messageField, &fid);

+    if (ret != MAMA_STATUS_OK)

+    {

+        return ret;

+    }

+

+    if (MAMA_STATUS_OK != mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, &field))

+    {

+        ret = mamaMsgField_getType(messageField, &type);

+        if (ret != MAMA_STATUS_OK)

+        {

+            return ret;

+        }

+        if (fieldCache->mUseFieldNames)

+        {

+            mamaMsgField_getName(messageField, &name);

+        }

+        mamaFieldCacheField_create(&field, fid, type, name);

+        ret = mamaFieldCacheMap_add(fieldCache->mMap, field);

+        if (ret != MAMA_STATUS_OK)

+        {

+            return ret;

+        }

+        fieldCache->mSize++;

+

+        mamaMsgField_getDescriptor(messageField, &descriptor);

+        if (descriptor)

+        {

+            mamaFieldCacheField_setDescriptor(field, descriptor);

+        }

+    }

+    else

+    {

+        type = field->mType;

+    }

+

+    if (fieldCache->mTrackModified && field->mPublish && !field->mIsModified)

+    {

+        field->mIsModified = 1;

+        mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)field);

+    }

+

+    switch (type)

+    {

+        case MAMA_FIELD_TYPE_BOOL:

+        {

+            mama_bool_t result;

+            mamaMsgField_getBool(messageField, &result);

+            mamaFieldCacheField_setBool(field, result);

+            break;

+        }

+        case MAMA_FIELD_TYPE_CHAR:

+        {

+            char value;

+            mamaMsgField_getChar(messageField, &value);

+            mamaFieldCacheField_setChar(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I8:

+        {

+            mama_i8_t value;

+            mamaMsgField_getI8(messageField, &value);

+            mamaFieldCacheField_setI8(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U8:

+        {

+            mama_u8_t value;

+            mamaMsgField_getU8(messageField, &value);

+            mamaFieldCacheField_setU8(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I16:

+        {

+            mama_i16_t value;

+            mamaMsgField_getI16(messageField, &value);

+            mamaFieldCacheField_setI16(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U16:

+        {

+            mama_u16_t value;

+            mamaMsgField_getU16(messageField, &value);

+            mamaFieldCacheField_setU16(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I32:

+        {

+            mama_i32_t value;

+            mamaMsgField_getI32(messageField, &value);

+            mamaFieldCacheField_setI32(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U32:

+        {

+            mama_u32_t value;

+            mamaMsgField_getU32(messageField, &value);

+            mamaFieldCacheField_setU32(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I64:

+        {

+            mama_i64_t value;

+            mamaMsgField_getI64(messageField, &value);

+            mamaFieldCacheField_setI64(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U64:

+        {

+            mama_u64_t value;

+            mamaMsgField_getU64(messageField, &value);

+            mamaFieldCacheField_setU64(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F32:

+        {

+            mama_f32_t value;

+            mamaMsgField_getF32(messageField, &value);

+            mamaFieldCacheField_setF32(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_QUANTITY:

+        case MAMA_FIELD_TYPE_F64:

+        {

+            mama_f64_t value;

+            mamaMsgField_getF64(messageField, &value);

+            mamaFieldCacheField_setF64(field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_STRING:

+        {

+            const char* value = NULL;

+            mamaMsgField_getString(messageField, &value);

+            mamaFieldCacheField_setString(field, value, 0);

+            break;

+        }

+        case MAMA_FIELD_TYPE_PRICE:

+        {

+            mamaMsgField_getPrice(messageField, fieldCache->mReusablePrice);

+            mamaFieldCacheField_setPrice(field, fieldCache->mReusablePrice);

+            break;

+        }

+        case MAMA_FIELD_TYPE_TIME:

+        {

+            mamaMsgField_getDateTime(messageField, fieldCache->mReusableDateTime);

+            mamaFieldCacheField_setDateTime(field, fieldCache->mReusableDateTime);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        {

+            const mama_i8_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorI8(messageField, &values, &size);

+            mamaFieldCacheField_setI8Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        {

+            const mama_u8_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorU8(messageField, &values, &size);

+            mamaFieldCacheField_setU8Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        {

+            const mama_i16_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorI16(messageField, &values, &size);

+            mamaFieldCacheField_setI16Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        {

+            const mama_u16_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorU16(messageField, &values, &size);

+            mamaFieldCacheField_setU16Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        {

+            const mama_i32_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorI32(messageField, &values, &size);

+            mamaFieldCacheField_setI32Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        {

+            const mama_u32_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorU32(messageField, &values, &size);

+            mamaFieldCacheField_setU32Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        {

+            const mama_i64_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorI64(messageField, &values, &size);

+            mamaFieldCacheField_setI64Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        {

+            const mama_u64_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorU64(messageField, &values, &size);

+            mamaFieldCacheField_setU64Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F32:

+        {

+            const mama_f32_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorF32(messageField, &values, &size);

+            mamaFieldCacheField_setF32Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F64:

+        {

+            const mama_f64_t* values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorF64(messageField, &values, &size);

+            mamaFieldCacheField_setF64Vector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+        {

+            const char** values = NULL;

+            mama_size_t size = 0;

+            mamaMsgField_getVectorString(messageField, &values, &size);

+            mamaFieldCacheField_setStringVector(field, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_PRICE:

+        {

+            /* TODO: mamaMsgField does not provide methods to get price vector

+            const mamaPrice* values = NULL;

+            mama_size_t size;

+            mamaMsgField_getVectorPrice(messageField, &values, &size);

+            mamaFieldCacheField_setPriceVector(field, values, size);

+             */

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_TIME:

+        {

+            /* TODO: mamaMsgField does not provide methods to get time vector

+            const mamaDateTime* values = NULL;

+            mama_size_t size;

+            mamaMsgField_getVectorDateTime(messageField, &values, &size);

+            mamaFieldCacheField_setDateTimeVector(field, values, size);

+             */

+            break;

+        }

+        default:

+            break;

+    }

+    return ret;

+}

+

+mama_status mamaFieldCache_updateCacheFromField(mamaFieldCache fieldCache,

+                                                const mamaFieldCacheField field)

+{

+    mama_status ret;

+    mama_fid_t fid;

+    mamaFieldType type;

+    mama_bool_t alreadyModified = 0;

+    const char* name = NULL;

+    mamaFieldCacheField cachedField = NULL;

+

+    ret = mamaFieldCacheField_getFid(field, &fid);

+    if (ret != MAMA_STATUS_OK)

+    {

+        return ret;

+    }

+

+    ret = mamaFieldCacheField_getType(field, &type);

+    if (ret != MAMA_STATUS_OK)

+    {

+        return ret;

+    }

+

+    mamaFieldCacheField_getName(field, &name);

+    if (MAMA_STATUS_OK != mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, &cachedField))

+    {

+        ret = mamaFieldCacheField_create(&cachedField, fid, type, NULL);

+        if (ret != MAMA_STATUS_OK)

+        {

+            return ret;

+        }

+        ret = mamaFieldCacheMap_add(fieldCache->mMap, cachedField);

+        if (ret != MAMA_STATUS_OK)

+        {

+            return ret;

+        }

+        fieldCache->mSize++;

+        if (field->mPublish && !field->mCheckModified)

+        {   /* Always publish */

+            mamaFieldCacheList_add(fieldCache->mAlwaysPublishFields, (void*)cachedField);

+        }

+        alreadyModified = 0;

+    }

+    else

+    {

+        alreadyModified = cachedField->mIsModified;

+    }

+

+    mamaFieldCacheField_copy(field, cachedField);

+

+    if (cachedField->mPublish && cachedField->mCheckModified

+        && !alreadyModified

+        && fieldCache->mTrackModified)

+    {

+        cachedField->mIsModified = 1;

+        mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)cachedField);

+    }

+

+    return ret;

+}

+

+mama_status mamaFieldCache_updateMsgField(mamaFieldCache fieldCache,

+                                          mamaFieldCacheField field,

+                                          mamaMsg message,

+                                          mama_bool_t useUpdate)

+{

+    mama_status status = MAMA_STATUS_OK;

+    mama_fid_t fid;

+    mamaFieldType type;

+    const char* name = NULL;

+

+    mamaFieldCacheField_getFid(field, &fid);

+    mamaFieldCacheField_getType(field, &type);

+    if (fieldCache->mUseFieldNames)

+    {

+        mamaFieldCacheField_getName(field, &name);

+    }

+

+    switch (type)

+    {

+        case MAMA_FIELD_TYPE_BOOL:

+        {

+            mama_bool_t value;

+            mamaFieldCacheField_getBool(field, &value);

+            status = useUpdate ? mamaMsg_updateBool(message, name, fid, value)

+                               : mamaMsg_addBool(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_CHAR:

+        {

+            char value;

+            mamaFieldCacheField_getChar(field, &value);

+            status = useUpdate ? mamaMsg_updateChar(message, name, fid, value)

+                               : mamaMsg_addChar(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I8:

+        {

+            mama_i8_t value;

+            mamaFieldCacheField_getI8(field, &value);

+            status = useUpdate ? mamaMsg_updateI8(message, name, fid, value)

+                               : mamaMsg_addI8(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U8:

+        {

+            mama_u8_t value;

+            mamaFieldCacheField_getU8(field, &value);

+            status = useUpdate ? mamaMsg_updateU8(message, name, fid, value)

+                               : mamaMsg_addU8(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I16:

+        {

+            mama_i16_t value;

+            mamaFieldCacheField_getI16(field, &value);

+            status = useUpdate ? mamaMsg_updateI16(message, name, fid, value)

+                               : mamaMsg_addI16(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U16:

+        {

+            mama_u16_t value;

+            mamaFieldCacheField_getU16(field, &value);

+            status = useUpdate ? mamaMsg_updateU16(message, name, fid, value)

+                               : mamaMsg_addU16(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I32:

+        {

+            mama_i32_t value;

+            mamaFieldCacheField_getI32(field, &value);

+            status = useUpdate ? mamaMsg_updateI32(message, name, fid, value)

+                               : mamaMsg_addI32(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U32:

+        {

+            mama_u32_t value;

+            mamaFieldCacheField_getU32(field, &value);

+            status = useUpdate ? mamaMsg_updateU32(message, name, fid, value)

+                               : mamaMsg_addU32(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I64:

+        {

+            mama_i64_t value;

+            mamaFieldCacheField_getI64(field, &value);

+            status = useUpdate ? mamaMsg_updateI64(message, name, fid, value)

+                               : mamaMsg_addI64(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U64:

+        {

+            mama_u64_t value;

+            mamaFieldCacheField_getU64(field, &value);

+            status = useUpdate ? mamaMsg_updateU64(message, name, fid, value)

+                               : mamaMsg_addU64(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F32:

+        {

+            mama_f32_t value;

+            mamaFieldCacheField_getF32(field, &value);

+            status = useUpdate ? mamaMsg_updateF32(message, name, fid, value)

+                               : mamaMsg_addF32(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_QUANTITY:

+        case MAMA_FIELD_TYPE_F64:

+        {

+            mama_f64_t value;

+            mamaFieldCacheField_getF64(field, &value);

+            status = useUpdate ? mamaMsg_updateF64(message, name, fid, value)

+                               : mamaMsg_addF64(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_STRING:

+        {

+            const char* value = NULL;

+            mama_size_t len;

+            mamaFieldCacheField_getString(field, &value, &len);

+            if (!value)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateString(message, name, fid, value)

+                                : mamaMsg_addString(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_PRICE:

+        {

+            const mamaPrice value = NULL;

+            mamaFieldCacheField_getPrice(field, &value);

+            if (!value)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updatePrice(message, name, fid, value)

+                               : mamaMsg_addPrice(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_TIME:

+        {

+            const mamaDateTime value = NULL;

+            mamaFieldCacheField_getDateTime(field, &value);

+            if (!value)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateDateTime(message, name, fid, value)

+                               : mamaMsg_addDateTime(message, name, fid, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        {

+            const mama_i8_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getI8Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorI8(message, name, fid, values, size)

+                               : mamaMsg_addVectorI8(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        {

+            const mama_u8_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getU8Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorU8(message, name, fid, values, size)

+                               : mamaMsg_addVectorU8(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        {

+            const mama_i16_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getI16Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorI16(message, name, fid, values, size)

+                               : mamaMsg_addVectorI16(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        {

+            const mama_u16_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getU16Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorU16(message, name, fid, values, size)

+                               : mamaMsg_addVectorU16(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        {

+            const mama_i32_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getI32Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorI32(message, name, fid, values, size)

+                               : mamaMsg_addVectorI32(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        {

+            const mama_u32_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getU32Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorU32(message, name, fid, values, size)

+                               : mamaMsg_addVectorU32(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        {

+            const mama_i64_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getI64Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorI64(message, name, fid, values, size)

+                               : mamaMsg_addVectorI64(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        {

+            const mama_u64_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getU64Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorU64(message, name, fid, values, size)

+                               : mamaMsg_addVectorU64(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F32:

+        {

+            const mama_f32_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getF32Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorF32(message, name, fid, values, size)

+                               : mamaMsg_addVectorF32(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F64:

+        {

+            const mama_f64_t* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getF64Vector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorF64(message, name, fid, values, size)

+                               : mamaMsg_addVectorF64(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+        {

+            const char** values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getStringVector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = useUpdate ? mamaMsg_updateVectorString(message, name, fid, values, size)

+                               : mamaMsg_addVectorString(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_PRICE:

+        {

+            const mamaPrice* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getPriceVector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = /*useUpdate ? mamaMsg_updateVectorPrice(message, name, fid, values, size)

+                               : */mamaMsg_addVectorPrice(message, name, fid, values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_TIME:

+        {

+            const mamaDateTime* values = NULL;

+            mama_size_t size = 0;

+            mamaFieldCacheField_getDateTimeVector(field, &values, &size);

+            if (!values)

+            {

+                return MAMA_STATUS_INVALID_ARG;

+            }

+            status = /*useUpdate ? mamaMsg_updateVectorTime(message, name, fid, values, size)

+                               : */mamaMsg_addVectorDateTime(message, name, fid, values, size);

+            break;

+        }

+        default:

+            status = MAMA_STATUS_NOT_FOUND;

+            break;

+    }

+    return status;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.h b/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.h

new file mode 100644

index 0000000..ba7dd71

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.h

@@ -0,0 +1,92 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacheimpl.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheImplH__

+#define MamaFieldCacheImplH__

+

+#include <mama/types.h>

+#include "fieldcachemap.h"

+#include "fieldcachelist.h"

+#include <wlock.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif

+

+/* This structure contains all of the types required to manage a field cache.

+ */

+typedef struct mamaFieldCacheImpl_

+{  

+    /* The map used to search and store entries in the cache. */

+    mamaFieldCacheMap mMap;

+

+    /* This iterator is used to iterate through a mama message whenever there

+     * is no dictionary.

+     */

+    mamaMsgIterator mIterator;

+

+    /* Lock object */

+    wLock mLock;

+

+    /* Size of the map */

+    mama_size_t mSize;

+

+    /* List of fields which must always be published in a delta msg */

+    mamaFieldCacheList mAlwaysPublishFields;

+

+    /* List of modified fields to be able to populate a delta msg without iterating

+       the entire cache */

+    mamaFieldCacheList mModifiedFields;

+

+    /* Reusable mamaDateTime */

+    mamaDateTime mReusableDateTime;

+

+    /* Reusable mamaPrice */

+    mamaPrice mReusablePrice;

+

+    /* If this value is true, then the cache will keep track of modified fields */

+    mama_bool_t mTrackModified;

+

+    /* If this value is true, then the cache will use locking */

+    mama_bool_t mUseLock;

+

+    mama_bool_t mUseFieldNames;

+

+    mama_bool_t mCachePayload;

+    mamaMsg mCacheMsg;

+} mamaFieldCacheImpl;

+

+mama_status mamaFieldCache_updateCacheFromMsgField(mamaFieldCache fieldCache,

+                                                   const mamaMsgField messageField);

+

+mama_status mamaFieldCache_updateCacheFromField(mamaFieldCache fieldCache,

+                                                const mamaFieldCacheField field);

+

+mama_status mamaFieldCache_updateMsgField(mamaFieldCache fieldCache,

+                                          mamaFieldCacheField field,

+                                          mamaMsg message,

+                                          mama_bool_t useUpdate);

+

+#if defined(__cplusplus)

+}

+#endif

+

+#endif /* MamaFieldCacheImplH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcacheiterator.c b/mama/c_cpp/src/c/fieldcache/fieldcacheiterator.c

new file mode 100644

index 0000000..2579237

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcacheiterator.c

@@ -0,0 +1,77 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacheiterator.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcacheiteratorimpl.h"

+#include "fieldcachemaparray.h"

+#include "fieldcacheimpl.h"

+

+mama_status mamaFieldCacheIterator_create(mamaFieldCacheIterator* iterator,

+                                          mamaFieldCache fieldCache)

+{

+    if (!iterator || !fieldCache)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    switch (gMamaFieldCacheMapType)

+    {

+    case MAMAFIELDCACHE_MAP_MODE_ARRAY:

+        return mamaFieldCacheMapIteratorArray_create(iterator, fieldCache->mMap);

+    default:

+        break;

+    }

+    return MAMA_STATUS_INVALID_ARG;

+}

+

+mama_status mamaFieldCacheIterator_destroy(mamaFieldCacheIterator iterator)

+{

+    if (!iterator)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    return iterator->mDestroyFunction(iterator);

+}

+

+mamaFieldCacheField mamaFieldCacheIterator_next(mamaFieldCacheIterator iterator)

+{

+    if (!iterator)

+    {

+        return NULL;

+    }

+    return iterator->mFunctionNext(iterator);

+}

+

+mama_bool_t mamaFieldCacheIterator_hasNext(mamaFieldCacheIterator iterator)

+{

+    if (!iterator)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    return iterator->mFunctionHasNext(iterator);

+}

+

+mamaFieldCacheField mamaFieldCacheIterator_begin(mamaFieldCacheIterator iterator)

+{

+    if (!iterator)

+    {

+        return NULL;

+    }

+    return iterator->mFunctionBegin(iterator);

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcacheiteratorimpl.h b/mama/c_cpp/src/c/fieldcache/fieldcacheiteratorimpl.h

new file mode 100644

index 0000000..1e1b556

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcacheiteratorimpl.h

@@ -0,0 +1,57 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacheiteratorimpl.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheIteratorImplH__

+#define MamaFieldCacheIteratorImplH__

+

+#include <mama/config.h>

+#include <mama/status.h>

+#include <mama/fieldcache/fieldcacheiterator.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/* The following defines are function pointers for use in the FieldCacheIterator

+ * structure.

+ */

+typedef mama_status (*fieldCacheIterator_destroy)(mamaFieldCacheIterator);

+

+typedef mamaFieldCacheField (*fieldCacheIterator_next)(mamaFieldCacheIterator);

+

+typedef mama_bool_t (*fieldCacheIterator_hasNext)(mamaFieldCacheIterator);

+

+typedef mamaFieldCacheField (*fieldCacheIterator_begin)(mamaFieldCacheIterator);

+

+/* Iterator */

+typedef struct mamaFieldCacheIteratorImpl_

+{

+    fieldCacheIterator_destroy mDestroyFunction;

+    fieldCacheIterator_next mFunctionNext;

+    fieldCacheIterator_hasNext mFunctionHasNext;

+    fieldCacheIterator_begin mFunctionBegin;

+} mamaFieldCacheIteratorImpl;

+

+#if defined(__cplusplus)

+}

+#endif /* defined(__cplusplus) */

+

+#endif /* MamaFieldCacheIteratorImplH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachelist.c b/mama/c_cpp/src/c/fieldcache/fieldcachelist.c

new file mode 100644

index 0000000..a4f5ef6

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachelist.c

@@ -0,0 +1,95 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachelist.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachelist.h"

+

+#define LIST_GROW_CHUNK_SIZE 32

+

+mama_status

+mamaFieldCacheList_create(mamaFieldCacheList* list)

+{

+    *list = (mamaFieldCacheList)calloc(1, sizeof(mamaFieldCacheListImpl));

+    (*list)->mLast = -1;

+    return mamaFieldCacheVector_create(&(*list)->mVector);

+}

+

+mama_status

+mamaFieldCacheList_destroy(mamaFieldCacheList list)

+{

+    mamaFieldCacheVector_destroy(list->mVector);

+    free(list);

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheList_free(mamaFieldCacheList list)

+{

+    list->mLast = -1;

+    return mamaFieldCacheVector_free(list->mVector);

+}

+

+mama_status

+mamaFieldCacheList_clear(mamaFieldCacheList list)

+{

+    list->mLast = -1;

+    return mamaFieldCacheVector_clear(list->mVector);

+}

+

+mama_status

+mamaFieldCacheList_add(mamaFieldCacheList list, void* item)

+{

+    mama_size_t vectorSize = 0;

+

+    mamaFieldCacheVector_getSize(list->mVector, &vectorSize);

+    ++list->mLast;

+    if (list->mLast >= vectorSize)

+    {

+        mamaFieldCacheVector_grow(list->mVector, vectorSize + LIST_GROW_CHUNK_SIZE);

+    }

+    return mamaFieldCacheVector_set(list->mVector, list->mLast, item);

+}

+

+mama_status

+mamaFieldCacheList_set(mamaFieldCacheList list, mama_size_t index, void* item)

+{

+    if (index > list->mLast)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    return mamaFieldCacheVector_set(list->mVector, index, item);

+}

+

+mama_status

+mamaFieldCacheList_get(mamaFieldCacheList list, mama_size_t index, void** item)

+{

+    if (index > list->mLast)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    return mamaFieldCacheVector_get(list->mVector, index, item);

+}

+

+mama_status

+mamaFieldCacheList_getSize(mamaFieldCacheList list, mama_size_t* size)

+{

+    *size = list->mLast + 1;

+    return MAMA_STATUS_OK;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachelist.h b/mama/c_cpp/src/c/fieldcache/fieldcachelist.h

new file mode 100644

index 0000000..e1e5e63

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachelist.h

@@ -0,0 +1,135 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachelist.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheListH__

+#define MamaFieldCacheListH__

+

+#include <mama/config.h>

+#include <mama/types.h>

+#include <mama/status.h>

+#include "fieldcachevector.h"

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/* This structure describes a generic dynamic list of items

+    */

+typedef struct mamaFieldCacheListImpl_

+{

+    /* Underlying structure */

+    mamaFieldCacheVector mVector;

+    /* Position of the last item */

+    mama_size_t mLast;

+} mamaFieldCacheListImpl;

+

+typedef mamaFieldCacheListImpl* mamaFieldCacheList;

+

+/**

+ * Create a generic list.

+ *

+ * @param lsit (out) The list to create.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_create(mamaFieldCacheList* list);

+

+/**

+ * Destroy a list. No memory is freed as items might require specific destruction

+ * functions. If items can be safely destroyed with free, then

+ * <code>mamaFieldCacheList_free</code> can be used to free all the items.

+ * In all the other cases, the user is responsible for freeing the item's specific

+ * allocated memory.

+ *

+ * @param list (in) The list to destroy.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_destroy(mamaFieldCacheList list);

+

+/**

+ * Free all not-NULL items in the list using free. This can be used only if the

+ * item was allocated with <code>malloc</code> or the like.

+ * This function does not destroy the list: mamaFieldCacheList_destroy must be called anyway.

+ *

+ * @param list (in) The list to free.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_free(mamaFieldCacheList list);

+

+/**

+ * Set to NULL all items in the lsit. This will not free any memory allocated for

+ * the items.

+ *

+ * @param list (in) The list to clear.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_clear(mamaFieldCacheList list);

+

+/**

+ * Add an item in the list.

+ *

+ * @param list (in) The list to add the value to.

+ * @param item (in) The item to add.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_add(mamaFieldCacheList list, void* item);

+

+/**

+ * Set an item in the list. Index must be in range (less than list size).

+ *

+ * @param list (in) The list to set the value to.

+ * @param index (in) The index of the item in the list.

+ * @param item (in) The item to set.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_set(mamaFieldCacheList list, mama_size_t index, void* item);

+

+/**

+ * Get an item from the list. Index must be in range (less than list size).

+ *

+ * @param list (in) The list to get the value from.

+ * @param index (in) The index of the item in the list.

+ * @param item (out) The item in the list.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_get(mamaFieldCacheList list, mama_size_t index, void** item);

+

+/**

+ * Get the size of the list.

+ *

+ * @param list (in) The list to get the size.

+ * @param size (out) The size of the list.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheList_getSize(mamaFieldCacheList list, mama_size_t* size);

+

+#if defined(__cplusplus)

+}

+#endif

+

+#endif                /* MamaFieldCacheListH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemap.c b/mama/c_cpp/src/c/fieldcache/fieldcachemap.c

new file mode 100644

index 0000000..64b5844

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemap.c

@@ -0,0 +1,96 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemap.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachemap.h"

+#include "fieldcachemaparray.h"

+#include "fieldcachemapbinary.h"

+#include "fieldcachemapmonitor.h"

+#include <assert.h>

+

+const mamaFieldCacheMapType gMamaFieldCacheMapType = MAMAFIELDCACHE_MAP_MODE_ARRAY;

+const mama_bool_t gUseMamaFieldCacheMapMonitor = 0;

+

+mama_status mamaFieldCacheMap_create(mamaFieldCacheMap* map)

+{

+    mamaFieldCacheMap localMap = NULL;

+    mamaFieldCacheMap monitorMap = NULL;

+    mama_status ret = MAMA_STATUS_NULL_ARG;

+

+    assert(map);

+    ret = MAMA_STATUS_INVALID_ARG;

+    switch(gMamaFieldCacheMapType)

+    {

+        case MAMAFIELDCACHE_MAP_MODE_ARRAY:

+            ret = mamaFieldCacheMapArray_create(&localMap);

+            break;

+        case MAMAFIELDCACHE_MAP_MODE_BINARY:

+            ret = mamaFieldCacheMapBinary_create(&localMap);

+            break;

+        default:

+            break;

+    }

+

+    if(ret == MAMA_STATUS_OK && gUseMamaFieldCacheMapMonitor)

+    {

+        ret = mamaFieldCacheMapMonitor_create(&monitorMap, localMap);

+        if(ret == MAMA_STATUS_OK)

+        {

+            localMap = monitorMap;

+        }

+        /* If something went wrong, go on without the monitor */

+    }

+

+    /* Return the map. */

+    *map = localMap;

+

+    return ret;

+}

+

+mama_status mamaFieldCacheMap_destroy(mamaFieldCacheMap map)

+{

+    assert(map);

+    return map->mDestroyFunction(map);

+}

+

+mama_status

+mamaFieldCacheMap_add(mamaFieldCacheMap map,mamaFieldCacheField field)

+{

+    assert(map);

+    return map->mAddFunction(map, field);

+}

+

+mama_status

+mamaFieldCacheMap_find(mamaFieldCacheMap map,

+                       mama_fid_t fid,

+                       mamaFieldType type,

+                       const char* name,

+                       mamaFieldCacheField* field)

+{

+    assert(map);

+    return map->mFindFunction(map, fid, type, name, (mamaFieldCacheField*)field);

+}

+

+mama_status

+mamaFieldCacheMap_clear(mamaFieldCacheMap map)

+{

+    assert(map);

+    return map->mClearFunction(map);

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemap.h b/mama/c_cpp/src/c/fieldcache/fieldcachemap.h

new file mode 100644

index 0000000..c0314e2

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemap.h

@@ -0,0 +1,113 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemap.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldMapH__

+#define MamaFieldMapH__

+

+#include <mama/config.h>

+#include <mama/status.h>

+#include <mama/types.h>

+#include <mama/fielddesc.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+   

+struct mamaFieldCacheMapImpl_;

+typedef struct mamaFieldCacheMapImpl_ mamaFieldCacheMapImpl;

+typedef mamaFieldCacheMapImpl* mamaFieldCacheMap;

+

+

+/* The following defines are function pointers for use in the FieldCacheMap

+ * structure.

+ */

+/* This function is used to destroy a search map. */

+typedef mama_status (* fieldCacheMap_destroy)(mamaFieldCacheMap);

+

+typedef mama_status (* fieldCacheMap_add)(

+        mamaFieldCacheMap,

+        mamaFieldCacheField);

+/* This function is used to find fields in a search map. */

+typedef mama_status (* fieldCacheMap_find)(

+        mamaFieldCacheMap,

+        mama_fid_t,

+        mamaFieldType,

+        const char*,

+        mamaFieldCacheField*);

+

+/* This function is used to clear a search map. */

+typedef mama_status (* fieldCacheMap_clear)(mamaFieldCacheMap);

+

+

+/* The search map contains function pointers and members common to the various

+ * search strategies.

+ */

+struct mamaFieldCacheMapImpl_

+{

+    /* This function is used to clear a map. */

+    fieldCacheMap_clear mClearFunction;

+

+    /* This function is used to destroy a map. */

+    fieldCacheMap_destroy mDestroyFunction;

+

+    /* This function is used to add new fields to a map. */

+    fieldCacheMap_add mAddFunction;

+

+    /* This function is used to find fields in a map. */

+    fieldCacheMap_find mFindFunction;

+};

+

+typedef enum

+{

+    MAMAFIELDCACHE_MAP_MODE_ARRAY,

+    MAMAFIELDCACHE_MAP_MODE_BINARY

+} mamaFieldCacheMapType;

+

+extern const mamaFieldCacheMapType gMamaFieldCacheMapType;

+extern const mama_bool_t gUseMamaFieldCacheMapMonitor;

+       

+mama_status

+mamaFieldCacheMap_create(mamaFieldCacheMap* map);

+

+mama_status

+mamaFieldCacheMap_destroy(mamaFieldCacheMap map);

+

+mama_status

+mamaFieldCacheMap_add(mamaFieldCacheMap map,

+                      mamaFieldCacheField field);

+

+mama_status

+mamaFieldCacheMap_find(mamaFieldCacheMap map,

+                       mama_fid_t fid,

+                       mamaFieldType type,

+                       const char* name,

+                       mamaFieldCacheField* field);

+

+mama_status

+mamaFieldCacheMap_clear(mamaFieldCacheMap map);

+

+

+#if defined(__cplusplus)

+}

+#endif /* defined(__cplusplus) */

+

+#endif /* MamaFieldMapH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.c b/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.c

new file mode 100644

index 0000000..d85a141

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.c

@@ -0,0 +1,263 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachemaparray.h"

+#include "fieldcacheimpl.h"

+#include "fieldcachefieldimpl.h"

+#include <mama/fieldcache/fieldcachefield.h>

+#include <stdlib.h>

+

+static const mama_u16_t MAP_ARRAY_CHUNK_SIZE = 64;

+

+static mama_fid_t mamaFieldCacheMapArray_convertFid(mama_fid_t fid)

+{

+    static mama_fid_t mFields[0xFFFF];

+    static mama_u16_t mCounter = 0;

+

+    mama_fid_t ret = mFields[fid];

+    if (ret != 0)

+    {

+        return ret - 1;

+    }

+

+    mFields[fid] = ++mCounter;

+    return mCounter - 1;

+}

+

+mama_status mamaFieldCacheMapArray_create(mamaFieldCacheMap* map)

+{

+    mamaFieldCacheMapArray arrayMap =

+            (mamaFieldCacheMapArray)calloc(1, sizeof(mamaFieldCacheMapArrayImpl));

+

+    arrayMap->mFieldArray =

+            (mamaFieldCacheField*)calloc(MAP_ARRAY_CHUNK_SIZE, sizeof(mamaFieldCacheField));

+    if (!arrayMap->mFieldArray)

+    {

+        free(arrayMap);

+        return MAMA_STATUS_NOMEM;

+    }

+    arrayMap->mSize = MAP_ARRAY_CHUNK_SIZE;

+

+    arrayMap->mBaseMap.mAddFunction = mamaFieldCacheMapArray_add;

+    arrayMap->mBaseMap.mClearFunction = mamaFieldCacheMapArray_clear;

+    arrayMap->mBaseMap.mDestroyFunction = mamaFieldCacheMapArray_destroy;

+    arrayMap->mBaseMap.mFindFunction = mamaFieldCacheMapArray_find;

+

+    *map = (mamaFieldCacheMap)arrayMap;

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapArray_destroy(mamaFieldCacheMap map)

+{

+    int i;

+

+    /* Cast the map to an array map. */

+    mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)map;

+

+    for (i = 0; i < arrayMap->mSize; i++)

+    {

+        mamaFieldCacheField field = arrayMap->mFieldArray[i];

+        if (field)

+        {

+            mamaFieldCacheField_destroy(field);

+        }

+    }

+

+    free(arrayMap->mFieldArray);

+    arrayMap->mFieldArray = NULL;

+

+    free((mamaFieldCacheMapArray)map);

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapArray_add(mamaFieldCacheMap map,

+                                       mamaFieldCacheField field)

+{

+    mamaFieldCacheMapArray arrayMap = NULL;

+    mama_fid_t cacheFid = 0;

+    mama_u16_t newSize;

+    mamaFieldCacheField* newArray = NULL;

+    int i;

+

+    /* Cast the map to an array map. */

+    arrayMap = (mamaFieldCacheMapArray)map;

+

+    /* Check to see if the entry has already been added. */

+    cacheFid = mamaFieldCacheMapArray_convertFid(field->mFid);

+    if(cacheFid < arrayMap->mSize && arrayMap->mFieldArray[cacheFid] != NULL)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+

+    /* Resize the array, if needed */

+    if (cacheFid >= arrayMap->mSize)

+    {

+        newSize = arrayMap->mSize;

+        do

+        {

+            newSize += MAP_ARRAY_CHUNK_SIZE;

+        }

+        while (newSize <= cacheFid);

+        newArray = (mamaFieldCacheField*)realloc(

+                (void*)arrayMap->mFieldArray,

+                newSize * sizeof(mamaFieldCacheField));

+        if (!newArray)

+        {

+            return MAMA_STATUS_NOMEM;

+        }

+        for (i = arrayMap->mSize; i < newSize ; i++)

+        {

+            newArray[i] = NULL;

+        }

+        arrayMap->mFieldArray = newArray;

+        arrayMap->mSize = newSize;

+    }

+

+    arrayMap->mFieldArray[cacheFid] = field;

+

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapArray_find(mamaFieldCacheMap map,

+                                        mama_fid_t fid,

+                                        mamaFieldType type,

+                                        const char* name,

+                                        mamaFieldCacheField* field)

+{

+    mamaFieldCacheMapArray arrayMap = NULL;

+    mama_fid_t cacheFid = 0;

+

+    /* Cast the map to an array map. */

+    arrayMap = (mamaFieldCacheMapArray)map;

+

+    cacheFid = mamaFieldCacheMapArray_convertFid(fid);

+    if (cacheFid >= arrayMap->mSize)

+    {

+        return MAMA_STATUS_NOT_FOUND;

+    }

+    /* Get the field from the array. */

+    *field = arrayMap->mFieldArray[cacheFid];

+    return (*field == NULL) ? MAMA_STATUS_NOT_FOUND : MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapArray_clear(mamaFieldCacheMap map)

+{

+    int i;

+

+    /* Cast the map to an array map. */

+    mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)map;

+

+    for (i = 0; i < arrayMap->mSize; i++)

+    {

+        mamaFieldCacheField field = arrayMap->mFieldArray[i];

+        if (field)

+        {

+            mamaFieldCacheField_destroy(field);

+            arrayMap->mFieldArray[i] = NULL;

+        }

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapIteratorArray_create(mamaFieldCacheIterator* iterator,

+                                                  mamaFieldCacheMap map)

+{

+    mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)map;

+

+    mamaFieldCacheMapIteratorArray arrayIterator =

+            (mamaFieldCacheMapIteratorArray)calloc(1, sizeof(mamaFieldCacheMapIteratorArrayImpl));

+

+    arrayIterator->mBaseIterator.mDestroyFunction = mamaFieldCacheMapIteratorArray_destroy;

+    arrayIterator->mBaseIterator.mFunctionNext = mamaFieldCacheMapIteratorArray_next;

+    arrayIterator->mBaseIterator.mFunctionHasNext = mamaFieldCacheMapIteratorArray_hasNext;

+    arrayIterator->mBaseIterator.mFunctionBegin = mamaFieldCacheMapIteratorArray_begin;

+

+    arrayIterator->mFieldCacheMap = arrayMap;

+    arrayIterator->mCurrentIndex = -1;

+

+    *iterator = (mamaFieldCacheIterator)arrayIterator;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapIteratorArray_destroy(mamaFieldCacheIterator iterator)

+{

+    free((mamaFieldCacheMapIteratorArray)iterator);

+    return MAMA_STATUS_OK;

+}

+

+mamaFieldCacheField mamaFieldCacheMapIteratorArray_next(mamaFieldCacheIterator iterator)

+{

+    mama_i32_t i;

+    mamaFieldCacheField nextField = NULL;

+    mamaFieldCacheMapIteratorArray arrayIterator =

+            (mamaFieldCacheMapIteratorArray)iterator;

+    mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)arrayIterator->mFieldCacheMap;

+   

+    for (i = arrayIterator->mCurrentIndex + 1; i < arrayMap->mSize; i++)

+    {

+        nextField = arrayMap->mFieldArray[i];

+        if (nextField != NULL)

+        {

+            arrayIterator->mCurrentIndex = i;

+            return nextField;

+        }

+    }

+

+    return NULL;

+}

+

+mama_bool_t mamaFieldCacheMapIteratorArray_hasNext(mamaFieldCacheIterator iterator)

+{

+    mama_i32_t i;

+    mamaFieldCacheMapIteratorArray arrayIterator =

+            (mamaFieldCacheMapIteratorArray)iterator;

+    mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)arrayIterator->mFieldCacheMap;

+

+    for (i = arrayIterator->mCurrentIndex + 1; i < arrayMap->mSize; i++)

+    {

+        if (arrayMap->mFieldArray[i] != NULL)

+            return 1;

+    }

+

+    return 0;

+}

+

+mamaFieldCacheField mamaFieldCacheMapIteratorArray_begin(mamaFieldCacheIterator iterator)

+{

+    mama_i32_t i;

+    mamaFieldCacheField nextField = NULL;

+    mamaFieldCacheMapIteratorArray arrayIterator =

+            (mamaFieldCacheMapIteratorArray)iterator;

+    mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)arrayIterator->mFieldCacheMap;

+

+    for (i = 0; i < arrayMap->mSize; i++)

+    {

+        nextField = arrayMap->mFieldArray[i];

+        if (nextField != NULL)

+        {

+            return nextField;

+        }

+    }

+

+    return NULL;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.h b/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.h

new file mode 100644

index 0000000..08c5e28

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.h

@@ -0,0 +1,90 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemaparray.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheMapArrayH__

+#define MamaFieldCacheMapArrayH__

+

+#include "fieldcachemap.h"

+#include "fieldcacheiteratorimpl.h"

+

+#if defined( __cplusplus )

+extern "C" {

+#endif /* defined( __cplusplus ) */

+

+typedef struct mamaFieldCacheMapArrayImpl_

+{

+    /* The base structure must appear first. */

+    mamaFieldCacheMapImpl mBaseMap;

+   

+    /* This array contains entries for the fields. */

+    mamaFieldCacheField* mFieldArray;

+

+    /* The size of the array. */

+    mama_u16_t mSize;

+} mamaFieldCacheMapArrayImpl;

+

+typedef mamaFieldCacheMapArrayImpl* mamaFieldCacheMapArray;

+

+

+typedef struct mamaFieldCacheMapIteratorArrayImpl_

+{

+    mamaFieldCacheIteratorImpl mBaseIterator;

+    mamaFieldCacheMapArray mFieldCacheMap;

+    mama_i32_t mCurrentIndex;

+} mamaFieldCacheMapIteratorArrayImpl;

+

+typedef mamaFieldCacheMapIteratorArrayImpl* mamaFieldCacheMapIteratorArray;

+

+

+/* Map */

+mama_status mamaFieldCacheMapArray_create(mamaFieldCacheMap* map);

+

+mama_status mamaFieldCacheMapArray_destroy(mamaFieldCacheMap map);

+

+mama_status mamaFieldCacheMapArray_add(mamaFieldCacheMap map,

+                                       mamaFieldCacheField field);

+

+mama_status mamaFieldCacheMapArray_find(mamaFieldCacheMap map,

+                                        mama_fid_t fid,

+                                        mamaFieldType type,

+                                        const char* name,

+                                        mamaFieldCacheField* field);

+

+mama_status mamaFieldCacheMapArray_clear(mamaFieldCacheMap map);

+

+

+/* Iterator */

+mama_status mamaFieldCacheMapIteratorArray_create(mamaFieldCacheIterator* iterator,

+                                                  mamaFieldCacheMap map);

+

+mama_status mamaFieldCacheMapIteratorArray_destroy(mamaFieldCacheIterator iterator);

+

+mamaFieldCacheField mamaFieldCacheMapIteratorArray_next(mamaFieldCacheIterator iterator);

+

+mama_bool_t mamaFieldCacheMapIteratorArray_hasNext(mamaFieldCacheIterator iterator);

+

+mamaFieldCacheField mamaFieldCacheMapIteratorArray_begin(mamaFieldCacheIterator iterator);

+

+#if defined( __cplusplus )

+}

+#endif /* defined( __cplusplus ) */

+

+#endif /* MamaFieldCacheMapArrayH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.c b/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.c

new file mode 100644

index 0000000..9660790

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.c

@@ -0,0 +1,79 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachemapbinary.h"

+

+mama_status mamaFieldCacheMapBinary_create(mamaFieldCacheMap* map)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mama_status mamaFieldCacheMapBinary_destroy(mamaFieldCacheMap map)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mama_status mamaFieldCacheMapBinary_add(mamaFieldCacheMap map,

+                                        mamaFieldCacheField field)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mama_status mamaFieldCacheMapBinary_find(mamaFieldCacheMap map,

+                                         mama_fid_t fid,

+                                         mamaFieldType type,

+                                         const char* name,

+                                         mamaFieldCacheField* field)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mama_status mamaFieldCacheMapBinary_clear(mamaFieldCacheMap map)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+/* Iterator */

+mama_status mamaFieldCacheMapIteratorBinary_create(mamaFieldCacheIterator* iterator,

+                                                   mamaFieldCacheMap map)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mama_status mamaFieldCacheMapIteratorBinary_destroy(mamaFieldCacheIterator iterator)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mamaFieldCacheField mamaFieldCacheMapIteratorBinary_next(mamaFieldCacheIterator iterator)

+{

+    return NULL;

+}

+

+mama_bool_t mamaFieldCacheMapIteratorBinary_hasNext(mamaFieldCacheIterator iterator)

+{

+    return MAMA_STATUS_NOT_IMPLEMENTED;

+}

+

+mamaFieldCacheField mamaFieldCacheMapIteratorBinary_begin(mamaFieldCacheIterator iterator)

+{

+    return NULL;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.h b/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.h

new file mode 100644

index 0000000..0b9c7c0

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.h

@@ -0,0 +1,72 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemapbinary.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheMapBinaryH__

+#define MamaFieldCacheMapBinaryH__

+

+#include "fieldcachemap.h"

+

+#if defined( __cplusplus )

+extern "C" {

+#endif /* defined( __cplusplus ) */

+

+typedef struct mamaFieldCacheMapBinaryImpl_

+{

+    /* The base structure must appear first. */

+    mamaFieldCacheMapImpl mBaseMap;

+

+} mamaFieldCacheMapBinaryImpl;

+

+typedef struct mamaFieldCacheMapBinaryImpl_* mamaFieldCacheMapBinary;

+

+/* Map */

+mama_status mamaFieldCacheMapBinary_create(mamaFieldCacheMap* map);

+

+mama_status mamaFieldCacheMapBinary_destroy(mamaFieldCacheMap map);

+

+mama_status mamaFieldCacheMapBinary_add(mamaFieldCacheMap map,

+                                        mamaFieldCacheField field);

+

+mama_status mamaFieldCacheMapBinary_find(mamaFieldCacheMap map,

+                                         mama_fid_t fid,

+                                         mamaFieldType type,

+                                         const char* name,

+                                         mamaFieldCacheField* field);

+

+mama_status mamaFieldCacheMapBinary_clear(mamaFieldCacheMap map);

+

+/* Iterator */

+mama_status mamaFieldCacheMapIteratorBinary_create(mamaFieldCacheIterator* iterator,

+                                                   mamaFieldCacheMap map);

+

+mama_status mamaFieldCacheMapIteratorBinary_destroy(mamaFieldCacheIterator iterator);

+

+mamaFieldCacheField mamaFieldCacheMapIteratorBinary_next(mamaFieldCacheIterator iterator);

+

+mama_bool_t mamaFieldCacheMapIteratorBinary_hasNext(mamaFieldCacheIterator iterator);

+

+mamaFieldCacheField mamaFieldCacheMapIteratorBinary_begin(mamaFieldCacheIterator iterator);

+

+#if defined( __cplusplus )

+}

+#endif /* defined( __cplusplus ) */

+

+#endif /* MamaFieldCacheMapBinaryH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.c b/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.c

new file mode 100644

index 0000000..47d1979

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.c

@@ -0,0 +1,74 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachemapmonitor.h"

+

+mama_status mamaFieldCacheMapMonitor_create(mamaFieldCacheMap* map,

+                                            mamaFieldCacheMap originalMap)

+{

+    mamaFieldCacheMapMonitor mapMonitor =

+             (mamaFieldCacheMapMonitor)calloc(1, sizeof(mamaFieldCacheMapMonitorImpl));

+

+             if(map == NULL)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+            

+    if(mapMonitor == NULL)

+    {

+        return MAMA_STATUS_NOMEM;

+    }

+

+    mapMonitor->mOriginalMap = originalMap;

+    *map = (mamaFieldCacheMap)mapMonitor;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapMonitor_destroy(mamaFieldCacheMap map)

+{

+    mamaFieldCacheMapMonitor mapMonitor = (mamaFieldCacheMapMonitor)map;

+    mamaFieldCacheMap_destroy(mapMonitor->mOriginalMap);

+    free(mapMonitor);

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheMapMonitor_clear(mamaFieldCacheMap map)

+{

+    mamaFieldCacheMapMonitor mapMonitor = (mamaFieldCacheMapMonitor)map;

+    return mamaFieldCacheMap_clear(mapMonitor->mOriginalMap);

+}

+

+mama_status mamaFieldCacheMapMonitor_add(mamaFieldCacheMap map,

+                                         mamaFieldCacheField field)

+{

+    mamaFieldCacheMapMonitor mapMonitor = (mamaFieldCacheMapMonitor)map;

+    return mamaFieldCacheMap_add(mapMonitor->mOriginalMap, field);

+}

+

+mama_status mamaFieldCacheMapMonitor_find(mamaFieldCacheMap map,

+                                          mama_fid_t fid,

+                                          mamaFieldType type,

+                                          const char* name,

+                                          mamaFieldCacheField* field)

+{

+    mamaFieldCacheMapMonitor mapMonitor = (mamaFieldCacheMapMonitor)map;

+    return mamaFieldCacheMap_find(mapMonitor->mOriginalMap, fid, type, name, field);

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.h b/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.h

new file mode 100644

index 0000000..b217793

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.h

@@ -0,0 +1,64 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachemapmonitor.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheMapMonitorH__

+#define MamaFieldCacheMapMonitorH__

+

+#include "fieldcachemap.h"

+

+#if defined( __cplusplus )

+extern "C" {

+#endif /* defined( __cplusplus ) */

+

+typedef struct mamaFieldCacheMapMonitorImpl_

+{

+    /* The base structure must appear first. */

+    mamaFieldCacheMapImpl mBaseMap;

+    mamaFieldCacheMap mOriginalMap;

+} mamaFieldCacheMapMonitorImpl;

+

+typedef struct mamaFieldCacheMapMonitorImpl_* mamaFieldCacheMapMonitor;

+

+/* map will take ownership of originalMap; it will be destroyed when calling

+ * mamaFieldCacheMapMonitor_destroy

+ */

+mama_status mamaFieldCacheMapMonitor_create(mamaFieldCacheMap* map,

+                                            mamaFieldCacheMap originalMap);

+

+/* This function will also destroy the original map */

+mama_status mamaFieldCacheMapMonitor_destroy(mamaFieldCacheMap map);

+

+mama_status mamaFieldCacheMapMonitor_clear(mamaFieldCacheMap map);

+

+mama_status mamaFieldCacheMapMonitor_add(mamaFieldCacheMap map,

+                                         mamaFieldCacheField field);

+

+mama_status mamaFieldCacheMapMonitor_find(mamaFieldCacheMap map,

+                                          mama_fid_t fid,

+                                          mamaFieldType type,

+                                          const char* name,

+                                          mamaFieldCacheField* field);

+

+#if defined( __cplusplus )

+}

+#endif /* defined( __cplusplus ) */

+

+#endif /* MamaFieldCacheMapMonitorH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcacherecord.c b/mama/c_cpp/src/c/fieldcache/fieldcacherecord.c

new file mode 100644

index 0000000..b6c140d

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcacherecord.c

@@ -0,0 +1,159 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacherecord.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include <mama/fieldcache/fieldcacherecord.h>

+#include "fieldcacherecordimpl.h"

+

+mama_status mamaFieldCacheRecord_create(mamaFieldCacheRecord* record)

+{

+    mama_status ret;

+    mamaFieldCacheRecord localRecord = NULL;

+

+    if (!record)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    localRecord = (mamaFieldCacheRecord)calloc(1, sizeof(mamaFieldCacheRecordImpl));

+    if (!localRecord)

+    {

+        return MAMA_STATUS_NOMEM;

+    }

+    ret = mamaFieldCacheVector_create(&localRecord->mFields);

+    if (ret != MAMA_STATUS_OK)

+    {

+        free(localRecord);

+        return ret;

+    }

+

+    *record = localRecord;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheRecord_destroy(mamaFieldCacheRecord record)

+{

+    int i;

+    void* field = NULL;

+

+    if (!record)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    for (i = 0; i < record->mSize; i++)

+    {

+        mamaFieldCacheVector_get(record->mFields, i, &field);

+        mamaFieldCacheField_destroy((mamaFieldCacheField)field);

+    }

+    mamaFieldCacheVector_destroy(record->mFields);

+    free(record);

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheRecord_clear(mamaFieldCacheRecord record)

+{

+    int i;

+    void* field = NULL;

+

+    if (!record)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    for (i = 0; i < record->mSize; i++)

+    {

+        mamaFieldCacheVector_get(record->mFields, i, &field);

+        mamaFieldCacheField_destroy((mamaFieldCacheField)field);

+        mamaFieldCacheVector_set(record->mFields, i, NULL);

+    }

+    record->mSize = 0;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheRecord_getSize(mamaFieldCacheRecord record, mama_size_t* size)

+{

+    if (!record || !size)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *size = record->mSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheRecord_add(mamaFieldCacheRecord record,

+                                     mama_fid_t fid,

+                                     mamaFieldType type,

+                                     const char* name,

+                                     mamaFieldCacheField* field)

+{

+    if (!record || !field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    *field = NULL;

+    mamaFieldCacheVector_grow(record->mFields, record->mSize + 10);

+

+    mamaFieldCacheField_create(field, fid, type, name);

+    mamaFieldCacheVector_set(record->mFields, record->mSize, *field);

+    record->mSize++;

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheRecord_getField(mamaFieldCacheRecord record,

+                              mama_size_t index,

+                              mamaFieldCacheField* field)

+{

+    if (!record || !field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    if (index >= record->mSize)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    mamaFieldCacheVector_get(record->mFields, index, (void**)field);

+    return MAMA_STATUS_OK;

+}

+

+mama_status mamaFieldCacheRecord_find(mamaFieldCacheRecord record,

+                                      mama_fid_t fid,

+                                      const char* name,

+                                      mamaFieldCacheField* field)

+{

+    mama_status ret;

+    int i;

+    mama_fid_t fieldId;

+   

+    if (!record || !field)

+    {

+        return MAMA_STATUS_NULL_ARG;

+    }

+    for (i = 0; i < record->mSize; i++)

+    {

+        fieldId = 0;

+        mamaFieldCacheVector_get(record->mFields, i, (void**)field);

+        ret = mamaFieldCacheField_getFid(*field, &fieldId);

+        if (ret == MAMA_STATUS_OK && fid == fieldId)

+        {

+            return MAMA_STATUS_OK;

+        }

+    }

+    *field = NULL;

+    return MAMA_STATUS_NOT_FOUND;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcacherecordimpl.h b/mama/c_cpp/src/c/fieldcache/fieldcacherecordimpl.h

new file mode 100644

index 0000000..b9c1adf

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcacherecordimpl.h

@@ -0,0 +1,49 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacherecordimpl.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheRecordImplH__

+#define MamaFieldCacheRecordImplH__

+

+#include <mama/config.h>

+#include <mama/fielddesc.h>

+#include <mama/types.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+#include "fieldcachevector.h"

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+    /* This structure describes a record of fields

+     */

+typedef struct mamaFieldCacheRecordImpl_

+{

+    /* dynamic resizable vector containing mamaFieldCacheField pointers */

+    mamaFieldCacheVector mFields;

+    /* number of fields stored */

+    mama_size_t mSize;

+} mamaFieldCacheRecordImpl;

+

+#if defined(__cplusplus)

+}

+#endif

+

+#endif                /* MamaFieldCacheRecordImplH__ */

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachevector.c b/mama/c_cpp/src/c/fieldcache/fieldcachevector.c

new file mode 100644

index 0000000..6feb776

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachevector.c

@@ -0,0 +1,127 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachevector.c#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include "fieldcachevector.h"

+

+mama_status

+mamaFieldCacheVector_create(mamaFieldCacheVector* vector)

+{

+    *vector = (mamaFieldCacheVector)calloc(1, sizeof(mamaFieldCacheVectorImpl));

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_destroy(mamaFieldCacheVector vector)

+{

+    if (vector->mData)

+    {

+        free(vector->mData);

+    }

+    free(vector);

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_free(mamaFieldCacheVector vector)

+{

+    int i;

+

+    if (!vector->mData)

+        return MAMA_STATUS_OK;

+

+    for (i = 0; i < vector->mSize; i++)

+    {

+        if (vector->mData[i])

+            free(vector->mData[i]);

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_clear(mamaFieldCacheVector vector)

+{

+    int i;

+

+    if (!vector->mData)

+        return MAMA_STATUS_OK;

+

+    for (i = 0; i < vector->mSize; i++)

+    {

+        vector->mData[i] = NULL;

+    }

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_set(mamaFieldCacheVector vector, mama_size_t index, void* item)

+{

+    if (index >= vector->mSize)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    vector->mData[index] = item;

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_get(mamaFieldCacheVector vector, mama_size_t index, void** item)

+{

+    if (index >= vector->mSize)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+    *item = vector->mData[index];

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_getSize(mamaFieldCacheVector vector, mama_size_t* size)

+{

+    *size = vector->mSize;

+    return MAMA_STATUS_OK;

+}

+

+mama_status

+mamaFieldCacheVector_grow(mamaFieldCacheVector vector, mama_size_t newAllocSize)

+{

+    int i;

+   

+    if (vector->mSize > newAllocSize)

+    {

+        return MAMA_STATUS_OK;

+    }

+    if (!vector->mData)

+    {

+        vector->mData = (void**)

+                malloc(sizeof(void*)*newAllocSize);

+    }

+    else

+    {

+        vector->mData = (void**)

+                realloc((void*)vector->mData, sizeof(void*)*newAllocSize);

+    }

+    for (i = vector->mSize; i < newAllocSize; i++)

+    {

+        vector->mData[i] = NULL;

+    }

+    vector->mSize = newAllocSize;

+    return MAMA_STATUS_OK;

+}

diff --git a/mama/c_cpp/src/c/fieldcache/fieldcachevector.h b/mama/c_cpp/src/c/fieldcache/fieldcachevector.h

new file mode 100644

index 0000000..bd02f57

--- /dev/null

+++ b/mama/c_cpp/src/c/fieldcache/fieldcachevector.h

@@ -0,0 +1,134 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachevector.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheVectorH__

+#define MamaFieldCacheVectorH__

+

+#include <mama/config.h>

+#include <mama/types.h>

+#include <mama/status.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/* This structure describes a generic dynamic vector of items

+    */

+typedef struct mamaFieldCacheVectorImpl_

+{

+    /* Pointer to void* data */

+    void** mData;

+    /* size of the allocated array */

+    mama_size_t mSize;

+} mamaFieldCacheVectorImpl;

+

+typedef mamaFieldCacheVectorImpl* mamaFieldCacheVector;

+

+/**

+ * Create a generic dynamic vector.

+ *

+ * @param vector (out) The vector to create.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_create(mamaFieldCacheVector* vector);

+

+/**

+ * Destroy a vector. No memory is freed as items might require specific destruction

+ * functions. If items can be safely destroyed with free, then

+ * <code>mamaFieldCacheVector_free</code> can be used to free all the items.

+ * In all the other cases, the user is responsible for freeing the item's specific

+ * allocated memory.

+ *

+ * @param vector (in) The vector to destroy.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_destroy(mamaFieldCacheVector vector);

+

+/**

+ * Free all not-NULL items in the vector using free. This can be used only if the

+ * item was allocated with <code>malloc</code> or the like.

+ * This function does not destroy the vector: mamaFieldCacheVector_destroy must be called anyway.

+ *

+ * @param vector (in) The vector to free.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_free(mamaFieldCacheVector vector);

+

+/**

+ * Set to NULL all items in the vector. This will not free any memory allocated for

+ * the items. The size of the vector will not be modified.

+ *

+ * @param vector (in) The vector to clear.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_clear(mamaFieldCacheVector vector);

+

+/**

+ * Set an item in the vector. Index must be in range (less than vector size).

+ *

+ * @param vector (in) The vector to set the value to.

+ * @param index (in) The index of the item in the vector.

+ * @param item (in) The item to set.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_set(mamaFieldCacheVector vector, mama_size_t index, void* item);

+

+/**

+ * Get an item from the vector. Index must be in range (less than vector size).

+ *

+ * @param vector (in) The vector to get the value from.

+ * @param index (in) The index of the item in the vector.

+ * @param item (out) The item in the vector.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_get(mamaFieldCacheVector vector, mama_size_t index, void** item);

+

+/**

+ * Get the size of the vector.

+ *

+ * @param vector (in) The vector to get the size.

+ * @param size (out) The size of the vector.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_getSize(mamaFieldCacheVector vector, mama_size_t* size);

+

+/**

+ * Reallocate the vector to be able to contain at least newAllocSize.

+ *

+ * @param vector (in) The vector to resize.

+ * @param newAllocSize (in) The new size.

+ * @return Result of the operation.

+ */

+mama_status

+mamaFieldCacheVector_grow(mamaFieldCacheVector vector, mama_size_t newAllocSize);

+

+#if defined(__cplusplus)

+}

+#endif

+

+#endif                /* MamaFieldCacheVectorH__ */

diff --git a/mama/c_cpp/src/c/mama/fieldcache/fieldcache.h b/mama/c_cpp/src/c/mama/fieldcache/fieldcache.h

new file mode 100644

index 0000000..0fb6502

--- /dev/null

+++ b/mama/c_cpp/src/c/mama/fieldcache/fieldcache.h

@@ -0,0 +1,368 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcache.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheH__

+#define MamaFieldCacheH__

+

+#include <mama/config.h>

+#include <mama/fielddesc.h>

+#include <mama/status.h>

+#include <mama/types.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif

+

+/**

+ * This function will create the field cache and allocate all associated memory.

+ * If this function succeeds then the cache should be destroyed by calling

+ * mamaFieldCache_destroy.

+ *

+ * @param fieldCache (out) To return the field cache.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NOMEM

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_create(mamaFieldCache* fieldCache);

+

+/**

+ * This function will destroy a field cache previously allocated by a call to

+ * mamaFieldCache_create.

+ *

+ * @param fieldCache (in) The field cache to destroy.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_destroy(mamaFieldCache fieldCache);

+

+/**

+ * This function will clear the field cache. The result is that the cache will

+ * be empty (no fields).

+ *

+ * @param fieldCache (in) The field cache to clear.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_clear(mamaFieldCache fieldCache);

+

+/**

+ * This function will return the number of fields in the cache.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param size (out) The number of fields in the cache.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_getSize(mamaFieldCache fieldCache, mama_size_t* size);

+

+/**

+ * This function will retrieve a field from the cache. If the field is not found,

+ * the output parameter will be set to NULL and MAMA_STATUS_NOT_FOUND is returned.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param fid (in) The field id to look up.

+ * @param name (in) The field name.

+ * @param field (out) The field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_NOT_FOUND

+ *      MAMA_STATUS_OK

+ *      Other error codes from the mama functions.

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_find(mamaFieldCache fieldCache,

+                    mama_fid_t fid,

+                    const char* name,

+                    mamaFieldCacheField* field);

+

+/**

+ * This function will retrieve a field from the cache. If it does not exist, a

+ * new one is created, added to the cache and returned.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param fid (in) The field id to look up.

+ * @param type (in) The field type.

+ * @param name (in) The field name.

+ * @param field (out) The existing field, if found or new one, if not found.

+ * @param existing (out) Flag to indicate whether the field was already present in the cache.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_NOMEM

+ *      MAMA_STATUS_OK

+ *      Other error codes from the mama functions.

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_findOrAdd(mamaFieldCache fieldCache,

+                         mama_fid_t fid,

+                         mamaFieldType type,

+                         const char* name,

+                         mamaFieldCacheField* field,

+                         mama_bool_t* existing);

+

+/**

+ * This function will set the modified flag for a field in the cache even if the

+ * value has not changed.

+ * The field must be present in the cache (No automatic check is performed).

+ *

+ * @param fieldCache (in) The field cache.

+ * @param field (in) The field to set to modified.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_setModified(mamaFieldCache fieldCache,

+                           mamaFieldCacheField field);

+

+/**

+ * Update the cache content with the field given.

+ * If the field is already present, it will be updated, otherwise it will be

+ * added to the cache.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param field (in) The field to get the content to update in the cache.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_applyField(mamaFieldCache fieldCache,

+                          const mamaFieldCacheField field);

+/*

+ * This function will automatically populate the field cache from the contents

+ * of the supplied message. Fields within the messages will be added to the cache

+ * if not already present. If the field is already present then the data will be

+ * updated.

+ *

+ * @param fieldCache (in) The field cache to populate.

+ * @param message (in) The <code>mamaMsg</code> to use to populate the cache.

+ * @param dictionary (in) The dictionary (optional: can be NULL).

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG 

+ *      MAMA_STATUS_OK

+ *      Other error codes from the mama functions.

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_applyMessage(mamaFieldCache fieldCache,

+                            const mamaMsg message,

+                            mamaDictionary dictionary);

+

+/*

+ * This function will automatically populate the field cache from the contents

+ * of the supplied mamaFieldCacheRecord. Fields within the record will be added

+ * to the cache if not already present. If the field is already present then the

+ * data will be updated.

+ *

+ * @param fieldCache (in) The field cache to populate.

+ * @param record (in) The <code>mamaFieldCacheRecord</code> to use to populate the cache.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ *      Other error codes from the mama functions.

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_applyRecord(mamaFieldCache fieldCache,

+                           const mamaFieldCacheRecord record);

+

+/**

+ * This function will return all the fields in the cache by updating the provided

+ * mamaMsg with the fields.

+ * With this function the provided message will be fully populated with all the

+ * fields in the cache.

+ *

+ * @param fieldCache (in) The field cache to obtain the fields from.

+ * @param message (in) This <code>mamaMsg</code> will be populated with all the fields.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ *      Other mama return codes.

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_getFullMessage(mamaFieldCache fieldCache,mamaMsg message);

+

+/**

+ * This function will return the set of fields that have changed since the last time

+ * this function was called.

+ * With this function the provided message will be fully populated with only the

+ * modified fields in the cache.

+ *

+ * @param fieldCache (in) The field cache to obtain the modified fields from.

+ * @param message (in) This <code>mamMsg</code> will be populated with the modified fields.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ *      Other mama return codes.

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_getDeltaMessage(mamaFieldCache fieldCache, mamaMsg message);

+

+/**

+ * This function will clear the list of all the modified fields and reset the modified flags

+ * for all the modified fields in the cache.

+ *

+ * @param fieldCache (in) The field cache.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_clearModifiedFields(mamaFieldCache fieldCache);

+

+

+/**

+ * This function will set the value of the track modification state flag; if this

+ * flag is set then changes to field values will be monitored. See the documentation

+ * for more information on the operation of the track modification state flag.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param trackModified (in) The track mod state flag, this should be non-zero

+ *                           to turn tracking on.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_setTrackModified(mamaFieldCache fieldCache, mama_bool_t trackModified);

+

+/**

+ * This function will return the value of the track modification state flag.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param trackModified (out) To return the track mod state flag, this will be

+ *                            non-zero if tracking is turned on.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_getTrackModified(mamaFieldCache fieldCache, mama_bool_t *trackModified);

+

+/**

+ * This function will set the value of the use-field-names state flag; if this

+ * flag is set then... See the documentation

+ * for more information on the operation of the use-field-names state flag.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param useFieldNames (in) The use field names state flag, this should be non-zero

+ *                           to turn tracking on.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_setUseFieldNames(mamaFieldCache fieldCache, mama_bool_t useFieldNames);

+

+/**

+ * This function will return the value of the use-field-names state flag.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param useFieldNames (out) To return the use-field-names state flag, this will

+ *                            be non-zero if use-field-names is turned on.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_getUseFieldNames(mamaFieldCache fieldCache, mama_bool_t *useFieldNames);

+

+/**

+ * This function will enable/disable cache locking.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param enable (in) The flag for enabling/disabling locking.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_setUseLock(mamaFieldCache fieldCache, mama_bool_t enable);

+

+/**

+ * This function will determine whether the cache is using locking or not.

+ *

+ * @param fieldCache (in) The field cache.

+ * @param locked (out) Indicates whether the cache is using locking or not.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_getUseLock(mamaFieldCache fieldCache, mama_bool_t* lockEnabled);

+

+/**

+ * This function will lock the cache.

+ *

+ * @param fieldCache (in) The field cache to lock.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_lock(mamaFieldCache fieldCache);

+

+/**

+ * This function will unlock the cache.

+ *

+ * @param fieldCache (in) The field cache to unlock.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCache_unlock(mamaFieldCache fieldCache);

+

+#if defined(__cplusplus)

+}

+#endif

+

+#endif /* MamaFieldCacheH__ */

diff --git a/mama/c_cpp/src/c/mama/fieldcache/fieldcachefield.h b/mama/c_cpp/src/c/mama/fieldcache/fieldcachefield.h

new file mode 100644

index 0000000..2c4e072

--- /dev/null

+++ b/mama/c_cpp/src/c/mama/fieldcache/fieldcachefield.h

@@ -0,0 +1,1093 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachefield.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheFieldH__

+#define MamaFieldCacheFieldH__

+

+#include <mama/config.h>

+#include <mama/fielddesc.h>

+#include <mama/types.h>

+#include <mama/status.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/**

+ * This function will check if a specific mama field type can be used to create

+ * a <code>mamaFieldCacheField</code>.

+ *

+ * @param type (in) The mamaFieldType to check.

+ * @return Whether the type can be used to create a mamaFieldCache field.

+ */

+MAMAExpDLL

+extern mama_bool_t

+mamaFieldCacheField_isSupported(mamaFieldType type);

+

+/**

+ * This function will create a mamaFieldCacheField that can be stored in a

+ * mamaFieldCache.

+ *

+ * @param field (out) The mamaFieldCacheField to create.

+ * @param fid (in) The field id of the new field.

+ * @param type (in) The type of the new field.

+ * @param type (in) The name of the new field (optional: can be NULL).

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NOMEM

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_create(mamaFieldCacheField* field,

+                           mama_fid_t fid,

+                           mamaFieldType type,

+                           const char* name);

+

+/**

+ * This function will destroy a <code>mamaFieldCacheField</code> previously

+ * allocated by a call to <code>mamaFieldCacheField_create</code>.

+ *

+ * @param field (in) The field to destroy.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_destroy(mamaFieldCacheField field);

+

+/**

+ * This function will copy a <code>mamaFieldCacheField</code> into another one.

+ *

+ * @param field (in) The source field to copy from.

+ * @param copy (out) The destination field to copy to.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_copy(const mamaFieldCacheField field, mamaFieldCacheField copy);

+

+/**

+ * This function will get the field id of a <code>mamaFieldCacheField</code>.

+ *

+ * @param field (in) The field.

+ * @param fid (out) The field id of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getFid(mamaFieldCacheField field, mama_fid_t* fid);

+

+/**

+ * This function will get the field type of a <code>mamaFieldCacheField</code>.

+ *

+ * @param field (in) The field.

+ * @param type (out) The type of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getType(mamaFieldCacheField field, mamaFieldType* type);

+

+/**

+ * This function will get the descriptor of a <code>mamaFieldCacheField</code>,

+ * if present.

+ *

+ * @param field (in) The field.

+ * @param name (out) The descriptor of the field (can be NULL).

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getName(mamaFieldCacheField field, const char** name);

+

+/**

+ * This function will set the descriptor of a <code>mamaFieldCacheField</code>.

+ *

+ * @param field (in) The field.

+ * @param desc (in) The <code>mamaFieldDescriptor</code> of the field (can be NULL).

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setDescriptor(mamaFieldCacheField field,

+                                  const mamaFieldDescriptor desc);

+

+/**

+ * This function will get the descriptor of a <code>mamaFieldCacheField</code>.

+ *

+ * @param field (in) The field.

+ * @param desc (out) The <code>mamaFieldDescriptor</code> of the field (can be NULL).

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getDescriptor(mamaFieldCacheField field,

+                                  const mamaFieldDescriptor* desc);

+

+/**

+ * This function will return whether the field has been modified.

+ *

+ * @param field (in) The field.

+ * @param modified (out) The modified state of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_isModified(mamaFieldCacheField field, mama_bool_t* modified);

+

+

+/**

+ * This function will set the publish flag of a <code>mamaFieldCacheField</code>.

+ * If set to false, the field will never be published.

+ *

+ * @param field (in) The field.

+ * @param publish (in) The publish flag of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setPublish(mamaFieldCacheField field, mama_bool_t publish);

+

+/**

+ * This function will get the publish flag of a <code>mamaFieldCacheField</code>.

+ *

+ * @param field (in) The field.

+ * @param publish (out) The publish flag of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getPublish(mamaFieldCacheField field, mama_bool_t* publish);

+

+/**

+ * This function will set the checkModifed flag of a <code>mamaFieldCacheField</code>.

+ * If set to true, the field will be published only if modified.

+ *

+ * @param field (in) The field.

+ * @param check (in) The checkModified flag.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setCheckModified(mamaFieldCacheField field, mama_bool_t check);

+

+/**

+ * The function will get the checkModified flag of a <code>mamaFieldCacheField</code>.

+ *

+ * @param field (in) The field.

+ * @param check (out) The checkModified flag of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getCheckModified(mamaFieldCacheField field, mama_bool_t* check);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type BOOL.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getBool (const mamaFieldCacheField field, mama_bool_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type CHAR.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getChar(const mamaFieldCacheField field, char* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type I8.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI8(const mamaFieldCacheField field, mama_i8_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type U8.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU8(const mamaFieldCacheField field, mama_u8_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type I16.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI16(const mamaFieldCacheField field, mama_i16_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type U16.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU16(const mamaFieldCacheField field, mama_u16_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type I32.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI32(const mamaFieldCacheField field, mama_i32_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type U32.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU32(const mamaFieldCacheField field, mama_u32_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type I64.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI64(const mamaFieldCacheField field, mama_i64_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type U64.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU64(const mamaFieldCacheField field, mama_u64_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type F32.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getF32(const mamaFieldCacheField field, mama_f32_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type F64.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getF64(const mamaFieldCacheField field, mama_f64_t* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type STRING.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @param len (out) The length of the string.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getString(const mamaFieldCacheField field,

+                              const char** result,

+                              mama_size_t* len);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type PRICE.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getPrice(const mamaFieldCacheField field,

+                             const mamaPrice* result);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type TIME.

+ *

+ * @param field (in) The field.

+ * @param result (out) The value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getDateTime(const mamaFieldCacheField field,

+                                const mamaDateTime* result);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type I8 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI8Vector(const mamaFieldCacheField field,

+                                const mama_i8_t** values,

+                                mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type U8 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU8Vector(const mamaFieldCacheField field,

+                                const mama_u8_t** values,

+                                mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type I16 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI16Vector(const mamaFieldCacheField field,

+                                 const mama_i16_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type U16 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU16Vector(const mamaFieldCacheField field,

+                                 const mama_u16_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type I32 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI32Vector(const mamaFieldCacheField field,

+                                 const mama_i32_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type U32 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU32Vector(const mamaFieldCacheField field,

+                                 const mama_u32_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type I64 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getI64Vector(const mamaFieldCacheField field,

+                                 const mama_i64_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the values a <code>mamaFieldCacheField</code> of type U64 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getU64Vector(const mamaFieldCacheField field,

+                                 const mama_u64_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type F32 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getF32Vector(const mamaFieldCacheField field,

+                                 const mama_f32_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type F64 vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getF64Vector(const mamaFieldCacheField field,

+                                 const mama_f64_t** values,

+                                 mama_size_t* size);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type STRING vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getStringVector(const mamaFieldCacheField field,

+                                    const char*** values,

+                                    mama_size_t* size);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type PRICE vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getPriceVector(const mamaFieldCacheField field,

+                                   const mamaPrice** values,

+                                   mama_size_t* size);

+

+/**

+ * This function will get the value a <code>mamaFieldCacheField</code> of type TIME vector.

+ *

+ * @param field (in) The field.

+ * @param values (out) The array of values of the field.

+ * @param size (out) The number of values.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_getDateTimeVector(const mamaFieldCacheField field,

+                                      const mamaDateTime** values,

+                                      mama_size_t* size);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type BOOL.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setBool(mamaFieldCacheField field, mama_bool_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type CHAR.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setChar(mamaFieldCacheField field, char value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type I8.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI8(mamaFieldCacheField field, mama_i8_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type U8.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU8(mamaFieldCacheField field, mama_u8_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type I16.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI16(mamaFieldCacheField field, mama_i16_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type U16.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU16(mamaFieldCacheField field, mama_u16_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type I32.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI32(mamaFieldCacheField field, mama_i32_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type U32.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU32(mamaFieldCacheField field, mama_u32_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type I64.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI64(mamaFieldCacheField field, mama_i64_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type U64.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU64(mamaFieldCacheField field, mama_u64_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type F32.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setF32(mamaFieldCacheField field, mama_f32_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type F64.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setF64(mamaFieldCacheField field, mama_f64_t value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type STRING.

+ * If parameter len is 0 then the length of the string is automatically computed

+ * using <code>strlen</code>.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @param len (in) The length of the string. Can be 0.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setString(const mamaFieldCacheField field,

+                              const char* value,

+                              mama_size_t len);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type PRICE.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setPrice(const mamaFieldCacheField field, const mamaPrice value);

+

+/**

+ * This function will set the value of a <code>mamaFieldCacheField</code> of type TIME.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setDateTime(const mamaFieldCacheField field,

+                                const mamaDateTime value);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type I8 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI8Vector(const mamaFieldCacheField field,

+                                const mama_i8_t* values,

+                                mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type U8 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU8Vector(const mamaFieldCacheField field,

+                                const mama_u8_t* values,

+                                mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type I16 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI16Vector(const mamaFieldCacheField field,

+                                 const mama_i16_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type U16 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU16Vector(const mamaFieldCacheField field,

+                                 const mama_u16_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type I32 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI32Vector(const mamaFieldCacheField field,

+                                 const mama_i32_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type U32 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU32Vector(const mamaFieldCacheField field,

+                                 const mama_u32_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type I64 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setI64Vector(const mamaFieldCacheField field,

+                                 const mama_i64_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type U64 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setU64Vector(const mamaFieldCacheField field,

+                                 const mama_u64_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type F32 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setF32Vector(const mamaFieldCacheField field,

+                                 const mama_f32_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type F64 vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setF64Vector(const mamaFieldCacheField field,

+                                 const mama_f64_t* values,

+                                 mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type STRING vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setStringVector(const mamaFieldCacheField field,

+                                    const char** values,

+                                    mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type PRICE vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setPriceVector(const mamaFieldCacheField field,

+                                   const mamaPrice* values,

+                                   mama_size_t size);

+

+/**

+ * This function will set the values of a <code>mamaFieldCacheField</code> of type TIME vector.

+ *

+ * @param field (in) The field to set the value to.

+ * @param value (in) The new value of the field.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheField_setDateTimeVector(const mamaFieldCacheField field,

+                                      const mamaDateTime* values,

+                                      mama_size_t size);

+

+#if defined(__cplusplus)

+}

+#endif /* defined(__cplusplus) */

+

+#endif /* MamaFieldCacheFieldH__ */

diff --git a/mama/c_cpp/src/c/mama/fieldcache/fieldcacheiterator.h b/mama/c_cpp/src/c/mama/fieldcache/fieldcacheiterator.h

new file mode 100644

index 0000000..1606c94

--- /dev/null

+++ b/mama/c_cpp/src/c/mama/fieldcache/fieldcacheiterator.h

@@ -0,0 +1,102 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacheiterator.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheIteratorH__

+#define MamaFieldCacheIteratorH__

+

+#include <mama/config.h>

+#include <mama/status.h>

+#include <mama/types.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/**

+ * This function will create an iterator to the given field cache and allocate all

+ * associated memory. If this function succeeds then the iterator should be destroyed

+ * by calling mamaFieldCacheIterator_destroy.

+ *

+ * @param iterator (out) The iterator to create.

+ * @param fieldCache (in) The cache to use to iterate.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheIterator_create(mamaFieldCacheIterator* iterator,

+                              mamaFieldCache fieldCache);

+

+/**

+ * This function will destroy a field cache iterator previously allocated by a call

+ * to mamaFieldCacheIterator_create.

+ *

+ * @param iterator (in) The iterator to destroy.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheIterator_destroy(mamaFieldCacheIterator iterator);

+

+/**

+ * This function will return the next field in the cache. If no other fields are

+ * present it will return NULL.

+ *

+ * @param iterator (in) The iterator to get the field from.

+ * @return A mamaFieldCacheField pointing to the next field.

+ */

+MAMAExpDLL

+extern mamaFieldCacheField

+mamaFieldCacheIterator_next(mamaFieldCacheIterator iterator);

+

+/**

+ * This function will return a flag indicating if there are remaining fields to

+ * iterate.

+ *

+ * @param iterator (in) The iterator to check for other fields.

+ * @return A flag indicating if there are other fields to iterate.

+ */

+MAMAExpDLL

+extern mama_bool_t

+mamaFieldCacheIterator_hasNext(mamaFieldCacheIterator iterator);

+

+/**

+ * This function will return the first field in the cache. If the cache is empty,

+ * a NULL field is returned.

+ *

+ * @param iterator (in) The iterator to get the first field from.

+ * @return The first field in cache.

+ */

+MAMAExpDLL

+extern mamaFieldCacheField

+mamaFieldCacheIterator_begin(mamaFieldCacheIterator iterator);

+

+#if defined(__cplusplus)

+}

+#endif /* defined(__cplusplus) */

+

+#endif /* MamaFieldCacheIteratorH__ */

diff --git a/mama/c_cpp/src/c/mama/fieldcache/fieldcacherecord.h b/mama/c_cpp/src/c/mama/fieldcache/fieldcacherecord.h

new file mode 100644

index 0000000..050b209

--- /dev/null

+++ b/mama/c_cpp/src/c/mama/fieldcache/fieldcacherecord.h

@@ -0,0 +1,152 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcacherecord.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheRecordH__

+#define MamaFieldCacheRecordH__

+

+#include <mama/config.h>

+#include <mama/fielddesc.h>

+#include <mama/types.h>

+#include <mama/status.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+#include <mama/fieldcache/fieldcachefield.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/**

+ * This function will create a mamaFieldCacheRecord.

+ *

+ * @param record (in) The record to create.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NOMEM

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_create(mamaFieldCacheRecord* record);

+

+/**

+ * This function will destroy a <code>mamaFieldCacheRecord</code> previously

+ * allocated by a call to <code>mamaFieldCacheRecord_create</code>.

+ * Note that all the fields contained in the record will be destroyed.

+ *

+ * @param record (in) The record to destroy.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_destroy(mamaFieldCacheRecord record);

+

+/**

+ * This function will clear a <code>mamaFieldCacheRecord</code>.

+ * Note that all the fields contained in the record will be destroyed.

+ *

+ * @param record (in) The record to destroy.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_clear(mamaFieldCacheRecord record);

+

+/**

+ * This function will return the number of fields stored in a record.

+ *

+ * @param record (in) The field to destroy.

+ * @param size (out) The size of the record.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_getSize(mamaFieldCacheRecord record, mama_size_t* size);

+

+/** This function will create and add a field to the record; the new field is

+ *  returned. The field will be destroyed when the record is destroyed.

+ *

+ * @param record (in) The record to add the field to.

+ * @param fid (in) The field id of the field to create and add to the record.

+ * @param type (in) The type of the field to create and add to the record.

+ * @param name (in) The name of the field to create and add to the record.

+ * @param field (out) The new field added to the record.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_add(mamaFieldCacheRecord record,

+                         mama_fid_t fid,

+                         mamaFieldType type,

+                         const char* name,

+                         mamaFieldCacheField* field);

+

+/** This function will retrieve a field from the record using a position in the Record

+ *  as in a normal C array.

+ *  This can be useful when iterating the fields of the record in a loop.

+ *  Note that position is not significative in a <code>mamaFieldCacheRecord</code>.

+ *

+ * @param record (in) The record to get the field from.

+ * @param index (in) The index of the field to get from the record.

+ * @param field (out) The field, if found.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_getField(mamaFieldCacheRecord record,

+                              mama_size_t index,

+                              mamaFieldCacheField* field);

+

+/** This function will retrieve a field from the record using the field id of the

+ *  field to get.

+ *

+ * @param record (in) The record to get the field from.

+ * @param fid (in) The field id of the field.

+ * @param field (out) The field, if found.

+ * @return Resulting status of the call which can be

+ *      MAMA_STATUS_NULL_ARG

+ *      MAMA_STATUS_INVALID_ARG

+ *      MAMA_STATUS_NOT_FOUND

+ *      MAMA_STATUS_OK

+ */

+MAMAExpDLL

+extern mama_status

+mamaFieldCacheRecord_find(mamaFieldCacheRecord record,

+                          mama_fid_t fid,

+                          const char* name,

+                          mamaFieldCacheField* field);

+

+#if defined(__cplusplus)

+}

+#endif /* defined(__cplusplus) */

+

+#endif /* MamaFieldCacheRecordH__ */

diff --git a/mama/c_cpp/src/c/mama/fieldcache/fieldcachetypes.h b/mama/c_cpp/src/c/mama/fieldcache/fieldcachetypes.h

new file mode 100644

index 0000000..8b4b82b

--- /dev/null

+++ b/mama/c_cpp/src/c/mama/fieldcache/fieldcachetypes.h

@@ -0,0 +1,52 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/c/fieldcache/fieldcachetypes.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MamaFieldCacheTypesH__

+#define MamaFieldCacheTypesH__

+

+#include <wombat/wConfig.h>

+

+#if defined(__cplusplus)

+extern "C" {

+#endif /* defined(__cplusplus) */

+

+/** This structure contains the information of a field cache.

+ */

+typedef struct mamaFieldCacheImpl_* mamaFieldCache;

+

+/** This structure contains the information of a field that can be stored in a

+ *  field cache.

+ */

+typedef struct mamaFieldCacheFieldImpl_* mamaFieldCacheField;

+

+/** This structure contains the information to store a set of fields.

+ */

+typedef struct mamaFieldCacheRecordImpl_* mamaFieldCacheRecord;

+

+/** This structure allows to iterate through a field cache.

+ */

+typedef struct mamaFieldCacheIteratorImpl_* mamaFieldCacheIterator;

+

+#if defined(__cplusplus)

+}

+#endif /* defined(__cplusplus) */

+

+#endif /* MamaFieldCacheTypesH__ */

diff --git a/mama/c_cpp/src/c/mamac.vcproj b/mama/c_cpp/src/c/mamac.vcproj

index 772dac4..f92aff0 100644

--- a/mama/c_cpp/src/c/mamac.vcproj

+++ b/mama/c_cpp/src/c/mamac.vcproj

@@ -370,6 +370,54 @@

                                                               >

                                               </File>

                                               <File

+                                                             RelativePath=".\fieldcache\fieldcache.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachefield.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachefieldimpl.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcacheimpl.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcacheiterator.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachelist.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemaparray.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemapbinary.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemap.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemapmonitor.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcacherecord.c"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachevector.c"

+                                                             >

+                                             </File>

+                                             <File

                                                               RelativePath=".\datetime.c"

                                                               >

                                               </File>

@@ -640,6 +688,66 @@

                                                               >

                                               </File>

                                               <File

+                                                             RelativePath=".\mama\fieldcache\fieldcache.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\fieldcachetypes.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\fieldcacherecord.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\fieldcacheiterator.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\fieldcachefield.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachefieldimpl.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcacheimpl.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcacheiteratorimpl.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemap.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachelist.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemapmonitor.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemapbinary.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachemaparray.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcacherecordimpl.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\fieldcachevector.h"

+                                                             >

+                                             </File>

+                                             <File

                                                               RelativePath=".\mama\datetime.h"

                                                               >

                                               </File>

diff --git a/mama/c_cpp/src/cpp/Makefile.am b/mama/c_cpp/src/cpp/Makefile.am

index 1a2593a..0f3adb4 100644

--- a/mama/c_cpp/src/cpp/Makefile.am

+++ b/mama/c_cpp/src/cpp/Makefile.am

@@ -92,7 +92,11 @@ nobase_include_HEADERS  = \

     mama/mamacpp.h \

               mama/MamaStat.h \

               mama/MamaStatsCollector.h \

-    mama/MamaReservedFields.h  

+    mama/MamaReservedFields.h \

+    mama/fieldcache/MamaFieldCacheField.h \

+    mama/fieldcache/MamaFieldCacheFieldTypes.h \

+    mama/fieldcache/MamaFieldCacheRecord.h \

+    mama/fieldcache/MamaFieldCache.h

 

 

 CPPFLAGS += -I@srcdir@ \

@@ -148,4 +152,9 @@ libmamacpp_la_SOURCES = \

               MamaStat.cpp \

               MamaStatsCollector.cpp \

     conflation/MamaConnection.cpp \

-    conflation/MamaServerConnection.cpp

+    conflation/MamaServerConnection.cpp \

+    fieldcache/MamaFieldCacheField.cpp \

+    fieldcache/MamaFieldCacheFieldTypes.cpp \

+    fieldcache/MamaFieldCacheRecord.cpp \

+    fieldcache/MamaFieldCache.cpp

+

diff --git a/mama/c_cpp/src/cpp/SConscript b/mama/c_cpp/src/cpp/SConscript

index 25ead88..d8bc0b7 100644

--- a/mama/c_cpp/src/cpp/SConscript

+++ b/mama/c_cpp/src/cpp/SConscript

@@ -71,6 +71,14 @@ InstConflationInclude = \

    mama/conflation/MamaConnection.h

""")

 

+InstFieldCacheInclude = \

+    Split("""

+   mama/fieldcache/MamaFieldCacheField.h

+   mama/fieldcache/MamaFieldCacheFieldTypes.h

+   mama/fieldcache/MamaFieldCacheRecord.h

+   mama/fieldcache/MamaFieldCache.h

+""")

+

includePath = []

includePath.append('.')

includePath.append('../c')

@@ -121,6 +129,10 @@ libmama_sources = \

    MamaStatsCollector.cpp

    conflation/MamaConnection.cpp

    conflation/MamaServerConnection.cpp

+   fieldcache/MamaFieldCacheField.cpp

+   fieldcache/MamaFieldCacheFieldTypes.cpp

+   fieldcache/MamaFieldCacheRecord.cpp

+   fieldcache/MamaFieldCache.cpp

""")

 

 env.Append(CPPPATH=includePath, LIBPATH=libPath)

@@ -133,3 +145,5 @@ Alias('install', env.Install('$libdir', lib))

Alias('install', env.Install('$prefix/include/mama', InstMamaInclude))

Alias('install', env.Install('$prefix/include/mama/conflation',

       InstConflationInclude))

+Alias('install', env.Install('$prefix/include/mama/fieldcache',

+      InstFieldCacheInclude))

diff --git a/mama/c_cpp/src/cpp/SConscript.win b/mama/c_cpp/src/cpp/SConscript.win

index dae0764..74c566e 100644

--- a/mama/c_cpp/src/cpp/SConscript.win

+++ b/mama/c_cpp/src/cpp/SConscript.win

@@ -54,11 +54,17 @@ MamaFt.cpp

MamaReservedFields.cpp

conflation\MamaConnection.cpp

conflation\MamaServerConnection.cpp

+fieldcache\MamaFieldCacheField.cpp

+fieldcache\MamaFieldCache.cpp

+fieldcache\MamaFieldCacheRecord.cpp

+fieldcache\MamaFieldCacheFieldTypes.cpp

""")

 

 headers = Glob('mama/*.h')

+fieldcacheHeaders = Glob('mama/fieldcache/*.h')

 

 env.InstallLibrary(sources, target)

 

 if ( env['build'] == 'dynamic' or len(env['buildtype']) == 1):

     env.Install('$prefix/include/mama',headers)

+    env.Install('$prefix/include/mama/fieldcache',fieldcacheHeaders)

diff --git a/mama/c_cpp/src/cpp/fieldcache/MamaFieldCache.cpp b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCache.cpp

new file mode 100644

index 0000000..24ebdbd

--- /dev/null

+++ b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCache.cpp

@@ -0,0 +1,310 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/fieldcache/MamaFieldCache.cpp#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include <mama/fieldcache/MamaFieldCache.h>

+#include <mama/fieldcache/MamaFieldCacheRecord.h>

+#include <mama/fieldcache/MamaFieldCacheField.h>

+#include <mama/MamaMsg.h>

+#include <mama/MamaDictionary.h>

+#include <mama/fieldcache/fieldcacheiterator.h>

+

+namespace Wombat

+{

+

+struct MamaFieldCache::MamaFieldCacheImpl

+{

+    MamaFieldCacheImpl()

+        : mCache(NULL)

+    {

+    }

+    ~MamaFieldCacheImpl()

+    {

+        clear();

+    }

+   

+    void clear();

+

+    mamaFieldCache mCache;

+    mutable MamaFieldCacheField mField;

+};

+

+void MamaFieldCache::MamaFieldCacheImpl::clear()

+{

+    // clear reusable container members

+    mField.getCValue() = NULL;

+    mField.clear();

+}

+

+

+MamaFieldCache::MamaFieldCache()

+    : mPimpl(new MamaFieldCacheImpl)

+{

+}

+

+MamaFieldCache::~MamaFieldCache()

+{

+    mamaFieldCache_destroy(mPimpl->mCache);

+    delete mPimpl;

+}

+

+void MamaFieldCache::create()

+{

+    if (mPimpl->mCache)

+        return; // Already created

+    mamaFieldCache_create(&mPimpl->mCache);

+}

+

+void MamaFieldCache::clear()

+{

+    mamaFieldCache_clear(mPimpl->mCache);

+    mPimpl->clear();

+}

+

+mama_size_t MamaFieldCache::getSize() const

+{

+    mama_size_t size = 0;

+    mamaFieldCache_getSize(mPimpl->mCache, &size);

+    return size;

+}

+   

+void MamaFieldCache::setTrackModified(bool value)

+{

+    mamaFieldCache_setTrackModified(mPimpl->mCache, (mama_bool_t)value);

+}

+

+bool MamaFieldCache::getTrackModified() const

+{

+    mama_bool_t value = 0;

+    mamaFieldCache_getTrackModified(mPimpl->mCache, &value);

+    return value;

+}

+

+void MamaFieldCache::setUseFieldNames(bool value)

+{

+    mamaFieldCache_setUseFieldNames(mPimpl->mCache, (mama_bool_t)value);

+}

+

+bool MamaFieldCache::getUseFieldNames() const

+{

+    mama_bool_t value = 0;

+    mamaFieldCache_getUseFieldNames(mPimpl->mCache, &value);

+    return value;

+}

+

+void MamaFieldCache::setUseLock(bool value)

+{

+    mamaFieldCache_setUseLock(mPimpl->mCache, (mama_bool_t)value);

+}

+

+bool MamaFieldCache::getUseLock() const

+{

+    mama_bool_t value = 0;

+    mamaFieldCache_getUseLock(mPimpl->mCache, &value);

+    return value;

+}

+

+void MamaFieldCache::lock()

+{

+    mamaFieldCache_lock(mPimpl->mCache);

+}

+   

+void MamaFieldCache::unlock()

+{

+    mamaFieldCache_unlock(mPimpl->mCache);

+}

+

+const MamaFieldCacheField* MamaFieldCache::find(mama_fid_t fid,

+                                                const char* name) const

+{

+    mamaFieldCacheField field = NULL;

+    mamaFieldCache_find(mPimpl->mCache, fid, name, &field);

+    if (!field)

+    {

+        return NULL;

+    }

+    mPimpl->mField.getCValue() = field;

+    return &mPimpl->mField;

+}

+

+MamaFieldCacheField* MamaFieldCache::find(mama_fid_t fid,

+                                          const char* name)

+{

+    mamaFieldCacheField field = NULL;

+    mamaFieldCache_find(mPimpl->mCache, fid, name, &field);

+    if (!field)

+    {

+        return NULL;

+    }

+    mPimpl->mField.getCValue() = field;

+    return &mPimpl->mField;

+}

+

+void MamaFieldCache::setModified(MamaFieldCacheField& field)

+{

+    mamaFieldCache_setModified(mPimpl->mCache, field.getCValue());

+}

+

+void MamaFieldCache::apply(const MamaFieldCacheField& field)

+{

+    mamaFieldCache_applyField(mPimpl->mCache, field.getCValue());

+}

+

+void MamaFieldCache::apply(const MamaMsg& msg, const MamaDictionary* dict)

+{

+    mamaFieldCache_applyMessage(mPimpl->mCache,

+            msg.getUnderlyingMsg(),

+            dict ? dict->getDictC() : NULL);

+}

+

+void MamaFieldCache::apply(const MamaFieldCacheRecord& record)

+{

+    mamaFieldCache_applyRecord(mPimpl->mCache, record.getCValue());

+}

+

+void MamaFieldCache::getFullMessage(MamaMsg& msg)

+{

+    mamaFieldCache_getFullMessage(mPimpl->mCache, msg.getUnderlyingMsg());

+}

+

+void MamaFieldCache::getDeltaMessage(MamaMsg& msg)

+{

+    mamaFieldCache_getDeltaMessage(mPimpl->mCache, msg.getUnderlyingMsg());

+}

+

+void MamaFieldCache::clearModifiedFields()

+{

+    mamaFieldCache_clearModifiedFields(mPimpl->mCache);

+}

+

+MamaFieldCache::iterator MamaFieldCache::begin()

+{

+    return iterator(mPimpl->mCache);

+}

+

+MamaFieldCache::const_iterator MamaFieldCache::begin() const

+{

+    return const_iterator(mPimpl->mCache);

+}

+

+MamaFieldCache::iterator MamaFieldCache::end()

+{

+    return iterator(NULL);

+}

+

+MamaFieldCache::const_iterator MamaFieldCache::end() const

+{

+    return const_iterator(NULL);

+}

+

+

+MamaFieldCache::MamaFieldCacheIterator::MamaFieldCacheIterator(mamaFieldCache fieldCache)

+    : mIterator(NULL)

+{

+    mamaFieldCacheIterator_create(&mIterator, fieldCache);

+    if (mamaFieldCacheIterator_hasNext(mIterator))

+    {

+        ++(*this); // Set to the begin value

+    }

+}

+

+MamaFieldCache::MamaFieldCacheIterator::MamaFieldCacheIterator(const MamaFieldCacheIterator& rhs)

+    : mIterator(rhs.mIterator)

+{

+    const_cast<MamaFieldCacheIterator&>(rhs).mIterator = NULL;

+    mField.getCValue() = rhs.mField.getCValue();

+}

+

+MamaFieldCache::MamaFieldCacheIterator::~MamaFieldCacheIterator ()

+{

+    mamaFieldCacheIterator_destroy(mIterator);

+    // This is only a container - it is not responsible for destroying the real C field

+    mField.getCValue() = NULL;

+}

+

+MamaFieldCache::MamaFieldCacheIterator&

+MamaFieldCache::MamaFieldCacheIterator::operator=(const MamaFieldCacheIterator& rhs)

+{

+    if (this != &rhs)

+    {

+        if (mIterator)

+        {

+            mamaFieldCacheIterator_destroy(mIterator);

+        }

+        mIterator = rhs.mIterator;

+        const_cast<MamaFieldCacheIterator&>(rhs).mIterator = NULL;

+        mField.getCValue() = rhs.mField.getCValue();

+    }

+    return *this;

+}

+

+bool MamaFieldCache::MamaFieldCacheIterator::operator==(const MamaFieldCacheIterator& rhs) const

+{

+    return mField == rhs.mField;

+}

+bool MamaFieldCache::MamaFieldCacheIterator::operator!=(const MamaFieldCacheIterator& rhs) const

+{

+    return mField != rhs.mField;

+}

+

+MamaFieldCache::MamaFieldCacheIterator&

+MamaFieldCache::MamaFieldCacheIterator::operator++()

+{

+    const_cast<MamaFieldCacheField&>(mField).getCValue() = mamaFieldCacheIterator_next(mIterator);

+    return *this;

+}

+

+

+MamaFieldCache::iterator::iterator(mamaFieldCache fieldCache)

+    : MamaFieldCacheIterator (fieldCache)

+{

+}

+

+MamaFieldCache::iterator::reference MamaFieldCache::iterator::operator*()

+{

+    return mField;

+}

+

+MamaFieldCache::iterator::pointer MamaFieldCache::iterator::operator->()

+{

+    return &mField;

+}

+

+MamaFieldCache::const_iterator::const_iterator(mamaFieldCache fieldCache)

+    : MamaFieldCacheIterator (fieldCache)

+{

+}

+   

+MamaFieldCache::const_iterator::const_iterator(const MamaFieldCache::iterator& it)

+    : MamaFieldCacheIterator(it)

+{

+}

+

+MamaFieldCache::const_iterator::reference MamaFieldCache::const_iterator::operator*()

+{

+    return mField;

+}

+

+MamaFieldCache::const_iterator::pointer MamaFieldCache::const_iterator::operator->()

+{

+    return &mField;

+}

+

+} // namespace Wombat

diff --git a/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheField.cpp b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheField.cpp

new file mode 100644

index 0000000..a34dbc3

--- /dev/null

+++ b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheField.cpp

@@ -0,0 +1,229 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheField.cpp#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include <mama/fieldcache/MamaFieldCacheField.h>

+#include <mama/fieldcache/fieldcachefield.h>

+#include <FieldDescriptorImpl.h>

+

+namespace Wombat

+{

+

+struct MamaFieldCacheField::MamaFieldCacheFieldImpl

+{

+    MamaFieldCacheFieldImpl();

+    ~MamaFieldCacheFieldImpl();

+   

+    void clear();

+   

+    const mamaFieldDescriptor* getFieldDescriptorC() const;

+

+    mamaFieldCacheField mField;

+    MamaFieldDescriptor mDescriptor;

+};

+

+MamaFieldCacheField::MamaFieldCacheFieldImpl::MamaFieldCacheFieldImpl()

+    : mField(NULL)

+    , mDescriptor(NULL)

+{

+}

+

+MamaFieldCacheField::MamaFieldCacheFieldImpl::~MamaFieldCacheFieldImpl()

+{

+    clear();

+}

+

+void MamaFieldCacheField::MamaFieldCacheFieldImpl::clear()

+{

+    // clear reusable container members

+    mDescriptor.mPimpl->mField = NULL;

+}

+

+const mamaFieldDescriptor*

+MamaFieldCacheField::MamaFieldCacheFieldImpl::getFieldDescriptorC() const

+{

+    return &mDescriptor.mPimpl->mField;

+}

+

+

+MamaFieldCacheField::MamaFieldCacheField()

+    : mPimpl(new MamaFieldCacheFieldImpl)

+{

+}

+

+MamaFieldCacheField::~MamaFieldCacheField()

+{

+    mamaFieldCacheField_destroy(mPimpl->mField);

+    delete mPimpl;

+}

+

+MamaFieldCacheField::MamaFieldCacheField(const MamaFieldCacheField& rhs)

+    : mPimpl(new MamaFieldCacheFieldImpl)

+{

+    create(rhs.getFid(), rhs.getType(), rhs.getName());

+    mamaFieldCacheField_copy(rhs.mPimpl->mField, mPimpl->mField);

+}

+

+MamaFieldCacheField& MamaFieldCacheField::operator=(const MamaFieldCacheField& rhs)

+{

+    if (this != &rhs)

+    {

+        mamaFieldCacheField_copy(rhs.mPimpl->mField, mPimpl->mField);

+    }

+    return *this;

+}

+

+bool MamaFieldCacheField::operator==(const MamaFieldCacheField& rhs) const

+{

+    return mPimpl->mField == rhs.mPimpl->mField;

+}

+

+bool MamaFieldCacheField::operator!=(const MamaFieldCacheField& rhs) const

+{

+    return mPimpl->mField != rhs.mPimpl->mField;

+}

+

+void MamaFieldCacheField::create(const MamaFieldDescriptor& descriptor)

+{

+    if (mPimpl->mField)

+        return; // Already created

+

+    mamaFieldCacheField_create(&mPimpl->mField,

+            descriptor.getFid(),

+            descriptor.getType(),

+            descriptor.getName());

+}

+

+void MamaFieldCacheField::create(

+        mama_fid_t fid,

+        mamaFieldType type,

+        const char* name)

+{

+    if (mPimpl->mField)

+        return; // Already created

+

+    mamaFieldCacheField_create(&mPimpl->mField, fid, type, name);

+}

+

+void MamaFieldCacheField::clear()

+{

+    mPimpl->clear();

+}

+

+mama_fid_t MamaFieldCacheField::getFid() const

+{

+    mama_fid_t value = 0;

+    mamaFieldCacheField_getFid(mPimpl->mField, &value);

+    return value;

+}

+   

+mamaFieldType MamaFieldCacheField::getType() const

+{

+    mamaFieldType value = MAMA_FIELD_TYPE_UNKNOWN;

+    mamaFieldCacheField_getType(mPimpl->mField, &value);

+    return value;

+}

+

+const char* MamaFieldCacheField::getName() const

+{

+    const char* cname = NULL;

+    mamaFieldCacheField_getName(mPimpl->mField, &cname);

+    return cname;

+}

+

+void MamaFieldCacheField::setDescriptor(const MamaFieldDescriptor* descriptor)

+{

+    mamaFieldCacheField_setDescriptor(

+            mPimpl->mField,

+            descriptor ? descriptor->mPimpl->mField : NULL);

+}

+

+const MamaFieldDescriptor* MamaFieldCacheField::getDescriptor() const

+{

+    const mamaFieldDescriptor descriptor = NULL;

+    mamaFieldCacheField_getDescriptor(mPimpl->mField, &descriptor);

+    mPimpl->mDescriptor.mPimpl->mField = descriptor;

+    return descriptor ? &mPimpl->mDescriptor : NULL;

+}

+

+bool MamaFieldCacheField::isModified() const

+{

+    mama_bool_t value = 0;

+    mamaFieldCacheField_isModified(mPimpl->mField, &value);

+    return value;

+}

+

+void MamaFieldCacheField::setPublish(bool value)

+{

+    mamaFieldCacheField_setPublish(mPimpl->mField, value);

+}

+   

+bool MamaFieldCacheField::getPublish() const

+{

+    mama_bool_t value = 0;

+    mamaFieldCacheField_getPublish(mPimpl->mField, &value);

+    return value;

+}

+

+void MamaFieldCacheField::setCheckModified(bool value)

+{

+    mamaFieldCacheField_setCheckModified(mPimpl->mField, value);

+}

+   

+bool MamaFieldCacheField::getCheckModified() const

+{

+    mama_bool_t value = 0;

+    mamaFieldCacheField_getCheckModified(mPimpl->mField, &value);

+    return value;

+}

+

+bool MamaFieldCacheField::isVector() const

+{

+    switch (getType())

+    {

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+        case MAMA_FIELD_TYPE_VECTOR_PRICE:

+        case MAMA_FIELD_TYPE_VECTOR_TIME:

+            return true;

+        default:

+            break;

+    }

+    return false;

+}

+

+mamaFieldCacheField& MamaFieldCacheField::getCValue()

+{

+    return mPimpl->mField;

+}

+

+const mamaFieldCacheField& MamaFieldCacheField::getCValue() const

+{

+    return mPimpl->mField;

+}

+

+} // namespace Wombat

diff --git a/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheFieldTypes.cpp b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheFieldTypes.cpp

new file mode 100644

index 0000000..ede1a7b

--- /dev/null

+++ b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheFieldTypes.cpp

@@ -0,0 +1,873 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheFieldTypes.cpp#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include <mama/fieldcache/MamaFieldCacheFieldTypes.h>

+#include <mama/fieldcache/fieldcachefield.h>

+#include <mama/price.h>

+#include <string>

+#include <sstream>

+

+namespace Wombat

+{

+

+// MAMA_FIELD_TYPE_CHAR

+template <>

+char MamaFieldCacheFieldChar::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    char res;

+    mamaFieldCacheField_getChar(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldChar::set(MamaFieldCacheField& field, const char& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setChar(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_BOOL

+template <>

+mama_bool_t MamaFieldCacheFieldBool::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_bool_t res;

+    mamaFieldCacheField_getBool(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldBool::set(MamaFieldCacheField& field, const mama_bool_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setBool(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_I8

+template <>

+mama_i8_t MamaFieldCacheFieldI8::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_i8_t res;

+    mamaFieldCacheField_getI8(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldI8::set(MamaFieldCacheField& field, const mama_i8_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setI8(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_U8

+template <>

+mama_u8_t MamaFieldCacheFieldU8::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_u8_t res;

+    mamaFieldCacheField_getU8(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldU8::set(MamaFieldCacheField& field, const mama_u8_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setU8(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_I16

+template <>

+mama_i16_t MamaFieldCacheFieldI16::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_i16_t res;

+    mamaFieldCacheField_getI16(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldI16::set(MamaFieldCacheField& field, const mama_i16_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setI16(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_U16

+template <>

+mama_u16_t MamaFieldCacheFieldU16::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_u16_t res;

+    mamaFieldCacheField_getU16(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldU16::set(MamaFieldCacheField& field, const mama_u16_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setU16(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_I32

+template <>

+mama_i32_t MamaFieldCacheFieldI32::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_i32_t res;

+    mamaFieldCacheField_getI32(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldI32::set(MamaFieldCacheField& field, const mama_i32_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setI32(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_U32

+template <>

+mama_u32_t MamaFieldCacheFieldU32::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_u32_t res;

+    mamaFieldCacheField_getU32(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldU32::set(MamaFieldCacheField& field, const mama_u32_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setU32(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_I64

+template <>

+mama_i64_t MamaFieldCacheFieldI64::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_i64_t res;

+    mamaFieldCacheField_getI64(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldI64::set(MamaFieldCacheField& field, const mama_i64_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setI64(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_U64

+template <>

+mama_u64_t MamaFieldCacheFieldU64::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_u64_t res;

+    mamaFieldCacheField_getU64(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldU64::set(MamaFieldCacheField& field, const mama_u64_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setU64(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_F32

+template <>

+mama_f32_t MamaFieldCacheFieldF32::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_f32_t res;

+    mamaFieldCacheField_getF32(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldF32::set(MamaFieldCacheField& field, const mama_f32_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setF32(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_F64

+template <>

+mama_f64_t MamaFieldCacheFieldF64::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mama_f64_t res;

+    mamaFieldCacheField_getF64(field.getCValue(), &res);

+    return res;

+}

+template <>

+void MamaFieldCacheFieldF64::set(MamaFieldCacheField& field, const mama_f64_t& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setF64(field.getCValue(), value);

+}

+

+// MAMA_FIELD_TYPE_STRING

+void MamaFieldCacheFieldString::set(MamaFieldCacheField& field,

+                                    const char* value,

+                                    mama_size_t len)

+{

+    checkType(field);

+    mamaFieldCacheField_setString(field.getCValue(), value, len);

+}

+const char* MamaFieldCacheFieldString::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    const char* res = NULL;

+    mama_size_t len = 0;

+    mamaFieldCacheField_getString(field.getCValue(), &res, &len);

+    return res;

+}

+

+// MAMA_FIELD_TYPE_PRICE

+void MamaFieldCacheFieldPrice::set(MamaFieldCacheField& field, const MamaPrice& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setPrice(field.getCValue(), value.getCValue());

+}   

+const MamaPrice& MamaFieldCacheFieldPrice::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mamaPrice res = NULL;

+    mamaFieldCacheField_getPrice(field.getCValue(), &res);

+    // res is pointer to the field in the cache - need to make a copy here

+    // otherwise the object containing MamaPrice returned would destroy the C

+    // field present in cache.

+    mamaPrice_copy(mPrice.getCValue(), res);

+    return mPrice;

+}

+

+// MAMA_FIELD_TYPE_TIME

+void MamaFieldCacheFieldDateTime::set(MamaFieldCacheField& field, const MamaDateTime& value)

+{

+    checkType(field);

+    mamaFieldCacheField_setDateTime(field.getCValue(), value.getCValue());

+}   

+const MamaDateTime& MamaFieldCacheFieldDateTime::get(const MamaFieldCacheField& field) const

+{

+    checkType(field);

+    mamaDateTime res = NULL;

+    mamaFieldCacheField_getDateTime(field.getCValue(), &res);

+    // res is pointer to the field in the cache - need to make a copy here

+    // otherwise the object containing MamaDateTime returned would destroy the C

+    // field present in cache.

+    mamaDateTime_copy(mDateTime.getCValue(), res);

+    return mDateTime;

+}

+

+// MAMA_FIELD_TYPE_VECTOR_I8

+template <>

+void MamaFieldCacheFieldI8Vector::set(MamaFieldCacheField& field,

+                                     const mama_i8_t* values,

+                                     mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setI8Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldI8Vector::get(const MamaFieldCacheField& field,

+                                      const mama_i8_t*& values,

+                                      mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getI8Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_i8_t& MamaFieldCacheFieldI8Vector::get(const MamaFieldCacheField& field,

+                                                  mama_size_t index) const

+{

+    checkType(field);

+    const mama_i8_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getI8Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldI8Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_U8

+template <>

+void MamaFieldCacheFieldU8Vector::set(MamaFieldCacheField& field,

+                                      const mama_u8_t* values,

+                                      mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setU8Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldU8Vector::get(const MamaFieldCacheField& field,

+                                      const mama_u8_t*& values,

+                                      mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getU8Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_u8_t& MamaFieldCacheFieldU8Vector::get(const MamaFieldCacheField& field,

+                                                  mama_size_t index) const

+{

+    const mama_u8_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getU8Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldU8Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_I16

+template <>

+void MamaFieldCacheFieldI16Vector::set(MamaFieldCacheField& field,

+                                       const mama_i16_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setI16Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldI16Vector::get(const MamaFieldCacheField& field,

+                                       const mama_i16_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getI16Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_i16_t& MamaFieldCacheFieldI16Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_i16_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getI16Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldI16Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_U16

+template <>

+void MamaFieldCacheFieldU16Vector::set(MamaFieldCacheField& field,

+                                       const mama_u16_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setU16Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldU16Vector::get(const MamaFieldCacheField& field,

+                                       const mama_u16_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getU16Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_u16_t& MamaFieldCacheFieldU16Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_u16_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getU16Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldU16Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_I32

+template <>

+void MamaFieldCacheFieldI32Vector::set(MamaFieldCacheField& field,

+                                       const mama_i32_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setI32Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldI32Vector::get(const MamaFieldCacheField& field,

+                                       const mama_i32_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getI32Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_i32_t& MamaFieldCacheFieldI32Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_i32_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getI32Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldI32Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_U32

+template <>

+void MamaFieldCacheFieldU32Vector::set(MamaFieldCacheField& field,

+                                       const mama_u32_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setU32Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldU32Vector::get(const MamaFieldCacheField& field,

+                                       const mama_u32_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getU32Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_u32_t& MamaFieldCacheFieldU32Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_u32_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getU32Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldU32Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_I64

+template <>

+void MamaFieldCacheFieldI64Vector::set(MamaFieldCacheField& field,

+                                       const mama_i64_t* values,

+                                       mama_size_t size)

+{

+    mamaFieldCacheField_setI64Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldI64Vector::get(const MamaFieldCacheField& field,

+                                       const mama_i64_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getI64Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_i64_t& MamaFieldCacheFieldI64Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_i64_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getI64Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldI64Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_U64

+template <>

+void MamaFieldCacheFieldU64Vector::set(MamaFieldCacheField& field,

+                                       const mama_u64_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setU64Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldU64Vector::get(const MamaFieldCacheField& field,

+                                       const mama_u64_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getU64Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_u64_t& MamaFieldCacheFieldU64Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_u64_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getU64Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldU64Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_F32

+template <>

+void MamaFieldCacheFieldF32Vector::set(MamaFieldCacheField& field,

+                                       const mama_f32_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setF32Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldF32Vector::get(const MamaFieldCacheField& field,

+                                       const mama_f32_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getF32Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_f32_t& MamaFieldCacheFieldF32Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_f32_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getF32Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldF32Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_F64

+template <>

+void MamaFieldCacheFieldF64Vector::set(MamaFieldCacheField& field,

+                                       const mama_f64_t* values,

+                                       mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setF64Vector(field.getCValue(), values, size);

+}

+template <>

+void MamaFieldCacheFieldF64Vector::get(const MamaFieldCacheField& field,

+                                       const mama_f64_t*& values,

+                                       mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getF64Vector(field.getCValue(), &values, &size);

+}

+template <>

+const mama_f64_t& MamaFieldCacheFieldF64Vector::get(const MamaFieldCacheField& field,

+                                                    mama_size_t index) const

+{

+    checkType(field);

+    const mama_f64_t* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getF64Vector(field.getCValue(), &values, &size);

+    if (index < size)

+        return values[index];

+    throw std::out_of_range("MamaFieldCacheFieldF64Vector::get");

+}

+

+// MAMA_FIELD_TYPE_VECTOR_STRING

+void MamaFieldCacheFieldStringVector::set(MamaFieldCacheField& field,

+                                          const char** values,

+                                          mama_size_t size)

+{

+    checkType(field);

+    mamaFieldCacheField_setStringVector(field.getCValue(), values, size);

+}

+void MamaFieldCacheFieldStringVector::get(const MamaFieldCacheField& field,

+                                          const char**& values,

+                                          mama_size_t& size) const

+{

+    checkType(field);

+    mamaFieldCacheField_getStringVector(field.getCValue(), &values, &size);

+}

+const char* MamaFieldCacheFieldStringVector::get(const MamaFieldCacheField& field,

+                                                 mama_size_t index) const

+{

+    checkType(field);

+    const char** values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getStringVector(field.getCValue(), &values, &size);

+    if (index < size)

+    {

+        return values[index];

+    }

+    return NULL;

+}

+

+// MAMA_FIELD_TYPE_VECTOR_PRICE

+void MamaFieldCacheFieldPriceVector::set(MamaFieldCacheField& field,

+                                         const MamaPrice* values,

+                                         mama_size_t size)

+{

+    checkType(field);

+    mamaPrice* cvalues = new mamaPrice[size];

+    for (mama_size_t i = 0; i < size; ++i)

+    {

+        cvalues[i] = values[i].getCValue();

+    }

+    mamaFieldCacheField_setPriceVector(field.getCValue(), cvalues, size);

+    delete[] cvalues;

+}

+void MamaFieldCacheFieldPriceVector::get(const MamaFieldCacheField& field,

+                                         const MamaPrice*& values,

+                                         mama_size_t& size) const

+{

+    checkType(field);

+    const mamaPrice* cvalues = NULL;

+    mamaFieldCacheField_getPriceVector(field.getCValue(), &cvalues, &size);

+    grow(size);

+    for (mama_size_t i = 0; i < size; ++i)

+    {

+        // We should avoid the copy (if we could assign the CValue)

+        mamaPrice_copy(mValues[i].getCValue(), cvalues[i]);

+    }

+    values = mValues;

+}

+const MamaPrice* MamaFieldCacheFieldPriceVector::get(const MamaFieldCacheField& field,

+                                                     mama_size_t index) const

+{

+    checkType(field);

+    const mamaPrice* values = NULL;

+    mama_size_t size = 0;

+    mamaFieldCacheField_getPriceVector(field.getCValue(), &values, &size);

+    if (index < size)

+    {

+        // We should avoid the copy (if we could assign the CValue)

+        mamaPrice_copy(mValue.getCValue(), values[index]);

+        return &mValue;

+    }

+    return NULL;

+}

+

+// MAMA_FIELD_TYPE_VECTOR_TIME

+void MamaFieldCacheFieldDateTimeVector::set(MamaFieldCacheField& field,

+                                            const MamaDateTime* values,

+                                            mama_size_t size)

+{

+    checkType(field);

+    mamaDateTime* cvalues = new mamaDateTime[size];

+    for (mama_size_t i = 0; i < size; ++i)

+    {

+        cvalues[i] = values[i].getCValue();

+    }

+    mamaFieldCacheField_setDateTimeVector(field.getCValue(), cvalues, size);

+    delete[] cvalues;

+}

+void MamaFieldCacheFieldDateTimeVector::get(const MamaFieldCacheField& field,

+                                            const MamaDateTime*& values,

+                                            mama_size_t& size) const

+{

+    checkType(field);

+    const mamaDateTime* cvalues = NULL;

+    mamaFieldCacheField_getDateTimeVector(field.getCValue(), &cvalues, &size);

+    grow(size);

+    for (mama_size_t i = 0; i < size; ++i)

+    {

+        // We should avoid the copy (if we could assign the CValue)

+        mamaDateTime_copy(mValues[i].getCValue(), cvalues[i]);

+    }

+    values = mValues;

+}

+const MamaDateTime* MamaFieldCacheFieldDateTimeVector::get(const MamaFieldCacheField& field,

+                                                           mama_size_t index) const

+{

+    checkType(field);

+    const mamaDateTime* values;

+    mama_size_t size;

+    mamaFieldCacheField_getDateTimeVector(field.getCValue(), &values, &size);

+    if (index < size)

+    {

+        // We should avoid the copy (if we could assign the CValue)

+        mamaDateTime_copy(mValue.getCValue(), values[index]);

+        return &mValue;

+    }

+    return NULL;

+}

+

+

+void setFieldValue(MamaFieldCacheField& field, const char* value)

+{

+    MamaFieldCacheFieldString setField;

+    setField.set(field, value);

+}

+

+void setFieldValue(MamaFieldCacheField& field, const MamaPrice& value)

+{

+    MamaFieldCacheFieldPrice setField;

+    setField.set(field, value);

+}

+

+void setFieldValue(MamaFieldCacheField& field, const MamaDateTime& value)

+{

+    MamaFieldCacheFieldDateTime setField;

+    setField.set(field, value);

+}

+

+void getFieldValue(const MamaFieldCacheField& field, const char*& value)

+{

+    MamaFieldCacheFieldString getField;

+    value = getField.get(field);

+}

+

+void getFieldValue(const MamaFieldCacheField& field, MamaPrice& value)

+{

+    MamaFieldCacheFieldPrice getField;

+    value = getField.get(field);

+}

+

+void getFieldValue(const MamaFieldCacheField& field, MamaDateTime& value)

+{

+    MamaFieldCacheFieldDateTime getField;

+    value = getField.get(field);

+}

+

+void getFieldValue(const MamaFieldCacheField& field,

+                   const char**& values,

+                   mama_size_t& size)

+{

+    MamaFieldCacheFieldStringVector getField;

+    getField.get(field, values, size);

+}

+

+void getFieldValue(const MamaFieldCacheField& field,

+                   const MamaPrice*& values,

+                   mama_size_t& size)

+{

+//    MamaFieldCacheFieldPriceVector getField;

+//    getField.get(field, values, size);

+    throw "getFieldValue for MamaPrice vector not implemented";

+}

+

+void getFieldValue(const MamaFieldCacheField& field,

+                   const MamaDateTime*& values,

+                   mama_size_t& size)

+{

+//    MamaFieldCacheFieldDateTimeVector getField;

+//    getField.get(field, values, size);

+    throw "getFieldValue for MamaDateTime vector not implemented";

+}

+

+

+void mamaFieldCacheFieldFromString(MamaFieldCacheField& field, const std::string& value)

+{

+    std::istringstream is(value);

+    if (field.getType() == MAMA_FIELD_TYPE_STRING)

+    {

+        MamaFieldCacheFieldString f;

+        f.set(field, value.c_str(), value.size());

+        return;

+    }

+    if (field.getType() == MAMA_FIELD_TYPE_PRICE)

+    {

+        MamaPrice val;

+        val.setFromString(value.c_str());

+        MamaFieldCacheFieldPrice f;

+        f.set(field, val);

+        return;

+    }

+    if (field.getType() == MAMA_FIELD_TYPE_TIME)

+    {

+        MamaDateTime val;

+        val.setFromString(value.c_str());

+        MamaFieldCacheFieldDateTime f;

+        f.set(field, val);

+        return;

+    }

+    switch (field.getType())

+    {

+        case MAMA_FIELD_TYPE_CHAR:

+        {

+            char val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_CHAR>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_BOOL:

+        {

+            mama_bool_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_BOOL>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I8:

+        {

+            mama_i8_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_I8>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U8:

+        {

+            mama_u8_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_U8>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I16:

+        {

+            mama_i16_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_I16>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U16:

+        {

+            mama_u16_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_U16>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I32:

+        {

+            mama_i32_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_I32>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U32:

+        {

+            mama_u32_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_U32>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I64:

+        {

+            mama_i64_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_I64>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U64:

+        {

+            mama_u64_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_U64>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F32:

+        {

+            mama_f32_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_F32>(), field, val);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F64:

+        {

+            mama_f64_t val;

+            is >> val;

+            setV(Type<MAMA_FIELD_TYPE_F64>(), field, val);

+            break;

+        }

+        default:

+            break;

+    }

+}

+

+} // namespace Wombat

diff --git a/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheRecord.cpp b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheRecord.cpp

new file mode 100644

index 0000000..bfff3db

--- /dev/null

+++ b/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheRecord.cpp

@@ -0,0 +1,152 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/fieldcache/MamaFieldCacheRecord.cpp#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ */

+

+#include <mama/fieldcache/MamaFieldCacheRecord.h>

+#include <mama/fieldcache/MamaFieldCacheField.h>

+#include <mama/fieldcache/fieldcacherecord.h>

+

+namespace Wombat

+{

+

+struct MamaFieldCacheRecord::MamaFieldCacheRecordImpl

+{

+    MamaFieldCacheRecordImpl()

+        : mRecord(NULL)

+    {

+    }

+    ~MamaFieldCacheRecordImpl()

+    {

+        clear();

+    }

+   

+    void clear();

+

+    mamaFieldCacheRecord mRecord;

+    mutable MamaFieldCacheField mField;

+};

+

+void MamaFieldCacheRecord::MamaFieldCacheRecordImpl::clear()

+{

+    // clear reusable container members

+    mField.getCValue() = NULL;

+    mField.clear();

+}

+

+

+MamaFieldCacheRecord::MamaFieldCacheRecord()

+    : mPimpl(new MamaFieldCacheRecordImpl)

+{

+}

+

+MamaFieldCacheRecord::~MamaFieldCacheRecord()

+{

+    mamaFieldCacheRecord_destroy(mPimpl->mRecord);

+    delete mPimpl;

+}

+

+void MamaFieldCacheRecord::create()

+{

+    if (mPimpl->mRecord)

+        return; // Already created

+

+    mamaFieldCacheRecord_create(&mPimpl->mRecord);

+}

+

+MamaFieldCacheField& MamaFieldCacheRecord::add(mama_fid_t fid,

+                                               mamaFieldType type,

+                                               const char* name)

+{

+    mamaFieldCacheField cfield = NULL;

+    mamaFieldCacheRecord_add(mPimpl->mRecord, fid, type, name, &cfield);

+    mPimpl->mField.getCValue() = cfield;

+    return mPimpl->mField;

+}

+

+MamaFieldCacheField& MamaFieldCacheRecord::add(const MamaFieldDescriptor& descriptor)

+{

+    mamaFieldCacheField cfield = NULL;

+    mamaFieldCacheRecord_add(mPimpl->mRecord,

+                             descriptor.getFid(),

+                             descriptor.getType(),

+                             descriptor.getName(),

+                             &cfield);

+    mPimpl->mField.getCValue() = cfield;

+    return mPimpl->mField;

+}

+

+const MamaFieldCacheField& MamaFieldCacheRecord::operator[](mama_size_t index) const

+{

+    mamaFieldCacheField cfield = NULL;

+    mamaFieldCacheRecord_getField(mPimpl->mRecord, index, &cfield);

+    mPimpl->mField.getCValue() = cfield;

+    return mPimpl->mField;

+}

+

+MamaFieldCacheField& MamaFieldCacheRecord::operator[](mama_size_t index)

+{

+    mamaFieldCacheField cfield = NULL;

+    mamaFieldCacheRecord_getField(mPimpl->mRecord, index, &cfield);

+    mPimpl->mField.getCValue() = cfield;

+    return mPimpl->mField;

+}

+

+const MamaFieldCacheField& MamaFieldCacheRecord::find(mama_fid_t fid,

+                                                      const char* name) const

+{

+    mamaFieldCacheField cfield = NULL;

+    mamaFieldCacheRecord_find(mPimpl->mRecord, fid, name, &cfield);

+    mPimpl->mField.getCValue() = cfield;

+    return mPimpl->mField;

+}

+

+MamaFieldCacheField& MamaFieldCacheRecord::find(mama_fid_t fid,

+                                                const char* name)

+{

+    mamaFieldCacheField cfield = NULL;

+    mamaFieldCacheRecord_find(mPimpl->mRecord, fid, name, &cfield);

+    mPimpl->mField.getCValue() = cfield;

+    return mPimpl->mField;

+}

+

+mama_size_t MamaFieldCacheRecord::getSize() const

+{

+    mama_size_t size = 0;

+    mamaFieldCacheRecord_getSize(mPimpl->mRecord, &size);

+    return size;

+}

+

+void MamaFieldCacheRecord::clear()

+{

+    mamaFieldCacheRecord_clear(mPimpl->mRecord);

+    mPimpl->clear();

+}

+

+mamaFieldCacheRecord MamaFieldCacheRecord::getCValue()

+{

+    return mPimpl->mRecord;

+}

+

+const mamaFieldCacheRecord MamaFieldCacheRecord::getCValue() const

+{

+    return mPimpl->mRecord;

+}

+

+} // namespace Wombat

diff --git a/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCache.h b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCache.h

new file mode 100644

index 0000000..e956889

--- /dev/null

+++ b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCache.h

@@ -0,0 +1,332 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCache.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MAMA_FIELD_CACHE_CPP_H__

+#define MAMA_FIELD_CACHE_CPP_H__

+

+#include <mama/mamacpp.h>

+#include <mama/fieldcache/MamaFieldCacheField.h>

+#include <mama/fieldcache/fieldcache.h>

+

+namespace Wombat

+{

+    class MamaMsg;

+    class MamaDictionary;

+    class MamaFieldCacheRecord;

+   

+/**

+ * The <code>MamaFieldCache</code> class is a collection of unordered

+ * <code>MamaFieldCacheField</code> elements. This class provides methods for creating

+ * and finding fields, applying changes to the fields in the cache and populating

+ * a MamaMsg with the fields in cache.

+ */

+class MAMACPPExpDLL MamaFieldCache

+{

+public:

+    /**

+     * The <code>MamaFieldCacheIterator</code> class provides a way to iterate over

+     * the fields contained in the cache.

+     * Two iterators are provided: one const and one non-const.

+     * To use it use the standard C++ notation <code>MamaFieldCache::iterator</code>.

+     */

+    class MAMACPPExpDLL MamaFieldCacheIterator

+    {

+    protected:

+        MamaFieldCacheIterator(mamaFieldCache fieldCache);

+    public:

+        MamaFieldCacheIterator(const MamaFieldCacheIterator&);

+        ~MamaFieldCacheIterator();

+

+        MamaFieldCacheIterator& operator=(const MamaFieldCacheIterator& rhs);

+

+        bool operator==(const MamaFieldCacheIterator& rhs) const;

+        bool operator!=(const MamaFieldCacheIterator& rhs) const;

+

+        MamaFieldCacheIterator& operator++();

+

+    protected:

+        mamaFieldCacheIterator mIterator;

+        MamaFieldCacheField mField;

+       

+    private:

+        friend class MamaFieldCache;

+    };

+   

+    /**

+     * Iterator type used to iterate over the fields contained in the cache.

+     * This iterator allows modification of fields in the cache.

+     */

+    class MAMACPPExpDLL iterator : public MamaFieldCacheIterator

+    {

+    protected:

+        iterator(mamaFieldCache fieldCache);

+

+    public:

+        typedef std::input_iterator_tag iterator_category;

+        typedef MamaFieldCacheField value_type;

+        typedef std::iterator_traits<MamaFieldCacheField> difference_type;

+        typedef MamaFieldCacheField* pointer;

+        typedef MamaFieldCacheField& reference;

+

+        reference operator*();

+        pointer operator->();

+

+    private:

+        friend class MamaFieldCache;

+    };

+    /**

+     * Iterator type used to iterate over the fields contained in the cache.

+     * This iterator does not allow modification of fields in the cache.

+     */

+    class MAMACPPExpDLL const_iterator : public MamaFieldCacheIterator

+    {

+    protected:

+        const_iterator(mamaFieldCache fieldCache);

+   

+    public:

+        const_iterator(const iterator& it);

+

+        typedef std::input_iterator_tag iterator_category;

+        typedef MamaFieldCacheField value_type;

+        typedef std::iterator_traits<MamaFieldCacheField> difference_type;

+        typedef const MamaFieldCacheField* pointer;

+        typedef const MamaFieldCacheField& reference;

+

+        reference operator*();

+        pointer operator->();

+

+    private:

+        friend class MamaFieldCache;

+    };

+

+public:

+    /**

+     * Constructor.

+     * Use <code>create</code> to create the actual cache.

+     */

+    MamaFieldCache();

+   

+    /**

+     * Destructor.

+     * This is called automatically when an object is destroyed. This method will

+     * clean all the memory allocated.

+     */

+    virtual ~MamaFieldCache();

+

+    /**

+     * Create a MamaFieldCache.

+     */

+    virtual void create();

+

+    /**

+     * Clear the <code>MamaFieldCache</code>.

+     * No fields will be present in the cache after this operation. The cache is

+     * ready to be used, as long as create has been called once.

+     */

+    virtual void clear();

+   

+    /**

+     * Return the number of fields in cache.

+     *

+     * @return The number of fields in cache.

+     */

+    virtual mama_size_t getSize() const;

+

+    /**

+     * Set if field modifications are tracked when creating a delta message.

+     * See method <code>getDeltaMessage</code>.

+     * When modifications are not tracked, then calling <code>getDeltaMessage</code>

+     * is the same as calling <code>getFullMessage</code>.

+     *

+     * @param value Specify whether field modifications will be tracked.

+     */

+    virtual void setTrackModified(bool value);

+

+    /**

+     * Return the value of the track modifications flag.

+     *

+     * @return Whether tracking modifications is enabled or not.

+     */

+    virtual bool getTrackModified() const;

+

+    /**

+     * Set if field names are used when adding fields to MamaMsg.

+     * See methods <code>getDeltaMessage</code> and <code>getFullMessage</code>.

+     *

+     * @param value Specify whether field names will be used.

+     */

+    virtual void setUseFieldNames(bool value);

+

+    /**

+     * Return the value of the use field names flag.

+     *

+     * @return Whether field names are enabled or not.

+     */

+    virtual bool getUseFieldNames() const;

+

+    /**

+     * Set if the cache uses a lock when some methods are called for thread safety.

+     *

+     * @param value Specify whether locking will be used.

+     */

+    virtual void setUseLock(bool value);

+

+    /**

+     * Return the value of the locking flag.

+     *

+     * @return Whether the cache is using a lock or not.

+     */

+    virtual bool getUseLock() const;

+

+    /**

+     * Lock the cache.

+     */

+    virtual void lock();

+   

+    /**

+     * Unlock the cache.

+     */

+    virtual void unlock();

+

+    /**

+     * Retrieve a field from the cache.

+     * If the field is not found then NULL is returned.

+     *

+     * @param fid Field id of the field to look up.

+     * @param name Field name of the field to look up.

+     * @return The field in the cache (if present)

+     */

+    virtual const MamaFieldCacheField* find(mama_fid_t fid,

+                                            const char* name = NULL) const;

+   

+    /**

+     * Retrieve a field from the cache.

+     * If the field is not found then NULL is returned.

+     *

+     * @param fid Field id of the field to look up.

+     * @param name Field name of the field to look up.

+     * @return The field in the cache (if present)

+     */

+    virtual MamaFieldCacheField* find(mama_fid_t fid,

+                                      const char* name = NULL);

+

+    /**

+     * Set the specified field as modified even if the value has not changed.

+     * @param field The field to set the modified flag to.

+     */

+    virtual void setModified(MamaFieldCacheField& field);

+   

+    /**

+     * Update the cache content with the field given.

+     * If the field is already present, it will be updated, otherwise it will be

+     * added to the cache.

+     *

+     * @param field The field to use for updating the cache.

+     */

+    virtual void apply(const MamaFieldCacheField& field);

+

+    /**

+     * Update the cache content with the data contained in the message.

+     *

+     * @param msg Reference to a <code>MamaMsg</code> containing the fields to

+     *            update in the cache.

+     * @param dict Reference to a <code>MamaDictionary</code> representing a data

+     *             dictionary.

+     */

+    virtual void apply(const MamaMsg& msg, const MamaDictionary* dict = NULL);

+

+    /**

+     * Update the cache content with the data contained in the record.

+     *

+     * @param record Reference to a <code>MamaFieldCacheRecord</code> containing

+     *               the fields to update in the cache.

+     */

+    virtual void apply(const MamaFieldCacheRecord& record);

+

+    /**

+     * Populate a MamaMsg with all the fields present in the cache.

+     *

+     * @param msg MamaMsg which will be populated with the fields from the cache.

+     */

+    virtual void getFullMessage(MamaMsg& msg);

+   

+    /**

+     * Populate a MamaMsg with all the fields currently modified in the cache.

+     * Note that this method also resets the modification state of the modified fields.

+     * If trackModifications flag is set to false, then this method is the same as

+     * <code>getFullMessage</code>.

+     *

+     * @param msg MamaMsg which will be populated with the modified fields from the cache.

+     */

+    virtual void getDeltaMessage(MamaMsg& msg);

+

+    /**

+     * Clear the list of all the modified fields and reset the modified flags

+     * for all the modified fields in the cache.

+     */

+    virtual void clearModifiedFields();

+

+    /**

+     * Return a constant iterator to the first field in the cache and allows to

+     * iterate over the fields in the cache.

+     *

+     * @return An iterator to the first element in the cache.

+     */

+    virtual const_iterator begin() const;

+

+    /**

+     * Return an iterator to the first field in the cache and allows to iterate

+     * over the fields in the cache.

+     *

+     * @return An iterator to the first element in the cache.

+     */

+    virtual iterator begin();

+

+    /**

+     * Return a const iterator to an invalid element and allows to check if an

+     * iterator has arrived to the end (no more elements to iterate).

+     * The content of this iterator must not be accessed.

+     *

+     * @return An iterator to the first element in the cache.

+     */

+    virtual const_iterator end() const;

+

+    /**

+     * Return an iterator to an invalid element and allows to check if an iterator

+     * has arrived to the end (no more elements to iterate).

+     * The content of this iterator must not be accessed.

+     *

+     * @return An iterator to the first element in the cache.

+     */

+    virtual iterator end();

+

+private:

+    MamaFieldCache(const MamaFieldCache&);

+    MamaFieldCache& operator=(const MamaFieldCache&);

+

+private:

+    struct MamaFieldCacheImpl;

+    MamaFieldCacheImpl* mPimpl;

+};

+

+} // namespace Wombat

+

+#endif // MAMA_FIELD_CACHE_CPP_H__

diff --git a/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheField.h b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheField.h

new file mode 100644

index 0000000..1e1a6f0

--- /dev/null

+++ b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheField.h

@@ -0,0 +1,216 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheField.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MAMA_FIELD_CACHE_FIELD_CPP_H__

+#define MAMA_FIELD_CACHE_FIELD_CPP_H__

+

+#include <mama/mamacpp.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+#include <mama/fieldcache/fieldcachefield.h>

+#include <cstring>

+

+namespace Wombat

+{

+

+    class MamaFieldDescriptor;

+

+/**

+ * The <code>MamaFieldCacheField</code> class is used to store the information on

+ * the type of a field and its value(s). This class does not provide methods to set

+ * and get the value (check the specific types of fields such as

+ * <code>MamaFieldCacheFieldBool<code/>).

+ */

+class MAMACPPExpDLL MamaFieldCacheField

+{

+public:

+    /**

+     * Constructor.

+     * Use <code>create</code> to create the actual field.

+     */

+    MamaFieldCacheField();

+    /**

+     * Destructor.

+     * This is called automatically when an object is destroyed. This method will

+     * clean all the memory allocated.

+     */

+    virtual ~MamaFieldCacheField();

+   

+    /**

+     * Copy constructor.

+     *

+     * @param

+     */

+    MamaFieldCacheField(const MamaFieldCacheField& rhs);

+   

+    /**

+     * Copy rhs into the current object.

+     *

+     * @param rhs The source MamaFielCacheField.

+     * @return The MamaFieldCacheField itself.

+     */

+    MamaFieldCacheField& operator=(const MamaFieldCacheField& rhs);

+

+    /**

+     * Return if the current field is equal to the specified field.

+     *

+     * @param rhs The other field to check equality.

+     * @return Whether the two fields are equal.

+     */

+    bool operator==(const MamaFieldCacheField& rhs) const;

+    /**

+     * Return if the current field is different from the specified field.

+     *

+     * @param rhs The other field to check difference.

+     * @return Whether the two fields are different.

+     */

+    bool operator!=(const MamaFieldCacheField& rhs) const;

+

+    /**

+     * Create a MamaFieldCacheField.

+     *

+     * @param descriptor Descriptor of the field to create.

+     */

+    virtual void create(const MamaFieldDescriptor& descriptor);

+    /**

+     * Create a MamaFieldCacheField.

+     *

+     * @param fid Field id of the field to create.

+     * @param type Field type of the field to create.

+     * @param name Name of the field to create.

+     */

+    virtual void create(mama_fid_t fid, mamaFieldType type, const char* name = NULL);

+   

+    /**

+     * Clear the <code>MamaFieldCacheField</code>.

+     * The field is ready to be used, as long as create has been called once.

+     */

+    virtual void clear();

+

+    /**

+     * Return the field id.

+     * If the field is not valid, then 0 is returned.

+     *

+     * @return The field id of the field.

+     */

+    virtual mama_fid_t getFid() const;

+   

+    /**

+     * Return the field type.

+     * If the field is not valid, then MAMA_FIELD_TYPE_UNKNOWN is returned.

+     *

+     * @return The field type of the field.

+     */

+    virtual mamaFieldType getType() const;

+   

+    /**

+     * Return the name of the field.

+     * If the name is not set, then NULL is returned.

+     * @return

+     */

+    const char* getName() const;

+   

+    /**

+     * Set the descriptor of the field.

+     *

+     * @param descriptor Pointer to the descriptor of the field.

+     */

+    void setDescriptor(const MamaFieldDescriptor* descriptor);

+   

+    /**

+     * Return the descriptor of the field.

+     * If the descriptor is not set, NULL is returned.

+     *

+     * @return Pointer to the descriptor of the field.

+     */

+    const MamaFieldDescriptor* getDescriptor() const;

+   

+    /**

+     * Return whether the field has been modified or not.

+     *

+     * @return Whether the field is modified.

+     */

+    virtual bool isModified() const;

+

+    /**

+     * Set the publish flag of the field.

+     * If set to false, the field is never published.

+     *

+     * @param value The publish flag.

+     */

+    virtual void setPublish(bool value = true);

+

+    /**

+     * Return the always publish flag of the field.

+     *

+     * @return The publish flag.

+     */

+    virtual bool getPublish() const;

+

+    /**

+     * Set the checkModifed flag of a field.

+     * If set to true, the field will be checked for modification before publishing.

+     *

+     * @param value The checkModified flag.

+     */

+    virtual void setCheckModified(bool value = true);

+

+    /**

+     * Return the checkModified flag of the field.

+     *

+     * @return The check modified flag.

+     */

+    virtual bool getCheckModified() const;

+

+    /**

+     * Return if the field is a vector (otherwise is a single-value field).

+     *

+     * @return If the field is a vector field.

+     */

+    virtual bool isVector() const;

+

+    mamaFieldCacheField& getCValue();

+    const mamaFieldCacheField& getCValue() const;

+

+private:

+    struct MamaFieldCacheFieldImpl;

+    MamaFieldCacheFieldImpl* mPimpl;

+};

+

+

+/**

+ * Base type for fields

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldBase

+{

+protected:

+    MamaFieldCacheFieldBase() {}

+

+public:

+    virtual ~MamaFieldCacheFieldBase() {}

+

+private: // Cannot copy MamaFieldCacheField objects

+    MamaFieldCacheFieldBase(const MamaFieldCacheFieldBase& field);

+    MamaFieldCacheFieldBase& operator=(const MamaFieldCacheFieldBase& field);

+};

+

+} // namespace Wombat

+

+#endif // MAMA_FIELD_CACHE_FIELD_CPP_H__

diff --git a/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheFieldTypes.h b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheFieldTypes.h

new file mode 100644

index 0000000..7da6586

--- /dev/null

+++ b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheFieldTypes.h

@@ -0,0 +1,1079 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheFieldTypes.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MAMA_FIELD_CACHE_FIELD_TYPES_CPP_H__

+#define MAMA_FIELD_CACHE_FIELD_TYPES_CPP_H__

+

+#include <mama/mamacpp.h>

+#include <mama/fieldcache/MamaFieldCacheField.h>

+#include <mama/MamaPrice.h>

+#include <mama/MamaDateTime.h>

+#include <stdexcept>

+

+namespace Wombat

+{

+

+/**

+ * MamaFieldCacheFieldBasic.

+ * Base class for basic single-value types. Allows to set and get the value of the field.

+ */

+template <typename T, mamaFieldType fieldType>

+class MAMACPPExpDLL MamaFieldCacheFieldBasic : public MamaFieldCacheFieldBase

+{

+public:

+    virtual ~MamaFieldCacheFieldBasic() {}

+

+    /**

+     * Set the field value.

+     *

+     * @param field The field to set the value to.

+     * @param value The new value of the field.

+     */

+    void set(MamaFieldCacheField& field, const T& value);

+    /**

+     * Return the value of the field.

+     *

+     * @param field The field to get the value from.

+     * @return The value of the field.

+     */

+    T get(const MamaFieldCacheField& field) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != fieldType)

+            throw std::invalid_argument("MamaFieldCacheFieldBasic");

+    }

+};

+

+// Basic single-value types

+/**

+ * MamaFieldCacheFieldChar.

+ * Class used to set and get the value of a char single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<char, MAMA_FIELD_TYPE_CHAR>

+    MamaFieldCacheFieldChar;

+/**

+ * MamaFieldCacheFieldBool.

+ * Class used to set and get the value of a bool single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_bool_t, MAMA_FIELD_TYPE_BOOL>

+    MamaFieldCacheFieldBool;

+/**

+ * MamaFieldCacheFieldI8.

+ * Class used to set and get the value of a mama_i8_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_i8_t, MAMA_FIELD_TYPE_I8>

+    MamaFieldCacheFieldI8;

+/**

+ * MamaFieldCacheFieldU8.

+ * Class used to set and get the value of a mama_u8_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_u8_t, MAMA_FIELD_TYPE_U8>

+    MamaFieldCacheFieldU8;

+/**

+ * MamaFieldCacheFieldI16.

+ * Class used to set and get the value of a mama_i16_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_i16_t, MAMA_FIELD_TYPE_I16>

+    MamaFieldCacheFieldI16;

+/**

+ * MamaFieldCacheFieldU16.

+ * Class used to set and get the value of a mama_u16_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_u16_t, MAMA_FIELD_TYPE_U16>

+    MamaFieldCacheFieldU16;

+/**

+ * MamaFieldCacheFieldI32.

+ * Class used to set and get the value of a mama_i32_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_i32_t, MAMA_FIELD_TYPE_I32>

+    MamaFieldCacheFieldI32;

+/**

+ * MamaFieldCacheFieldU32.

+ * Class used to set and get the value of a mama_u32_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_u32_t, MAMA_FIELD_TYPE_U32>

+    MamaFieldCacheFieldU32;

+/**

+ * MamaFieldCacheFieldI64.

+ * Class used to set and get the value of a mama_i64_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_i64_t, MAMA_FIELD_TYPE_I64>

+    MamaFieldCacheFieldI64;

+/**

+ * MamaFieldCacheFieldU64.

+ * Class used to set and get the value of a mama_u64_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_u64_t, MAMA_FIELD_TYPE_U64>

+    MamaFieldCacheFieldU64;

+/**

+ * MamaFieldCacheFieldF32.

+ * Class used to set and get the value of a mama_f32_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_f32_t, MAMA_FIELD_TYPE_F32>

+    MamaFieldCacheFieldF32;

+/**

+ * MamaFieldCacheFieldF64.

+ * Class used to set and get the value of a mama_f64_t single-value <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldBasic<mama_f64_t, MAMA_FIELD_TYPE_F64>

+    MamaFieldCacheFieldF64;

+

+// Special single-value types

+/**

+ * MamaFieldCacheFieldString.

+ * Class used to set and get the value of a char* single-value <code>MamaFieldCacheField</code>.

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldString : public MamaFieldCacheFieldBase

+{

+public:

+    /**

+     * Set the field value.

+     *

+     * @param field The field to set the value to.

+     * @param value The new value of the field.

+     */

+    void set(MamaFieldCacheField& field, const char* value, mama_size_t len = 0);

+    /**

+     * Return the value of the field.

+     *

+     * @param field The field to get the value from.

+     * @return The value of the field.

+     */

+    const char* get(const MamaFieldCacheField& field) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != MAMA_FIELD_TYPE_STRING)

+            throw std::invalid_argument("MamaFieldCacheFieldString");

+    }

+};

+

+/**

+ * MamaFieldCacheFieldPrice.

+ * Class used to set and get the value of a MamaPrice single-value <code>MamaFieldCacheField</code>.

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldPrice : public MamaFieldCacheFieldBase

+{

+public:

+    /**

+     * Set the field value.

+     *

+     * @param field The field to set the value to.

+     * @param value The new value of the field.

+     */

+    void set(MamaFieldCacheField& field, const MamaPrice& value);

+    /**

+     * Return the value of the field.

+     *

+     * @param field The field to get the value from.

+     * @return The value of the field.

+     */

+    const MamaPrice& get(const MamaFieldCacheField& field) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != MAMA_FIELD_TYPE_PRICE)

+            throw std::invalid_argument("MamaFieldCacheFieldPrice");

+    }

+

+private:

+    mutable MamaPrice mPrice;

+};

+

+/**

+ * MamaFieldCacheFieldDateTime.

+ * Class used to set and get the value of a MamaDateTime single-value <code>MamaFieldCacheField</code>.

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldDateTime : public MamaFieldCacheFieldBase

+{

+public:

+    /**

+     * Set the field value.

+     *

+     * @param field The field to set the value to.

+     * @param value The new value of the field.

+     */

+    void set(MamaFieldCacheField& field, const MamaDateTime& value);

+    /**

+     * Return the value of the field.

+     *

+     * @param field The field to get the value from.

+     * @return The value of the field.

+     */

+    const MamaDateTime& get(const MamaFieldCacheField& field) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != MAMA_FIELD_TYPE_TIME)

+            throw std::invalid_argument("MamaFieldCacheFieldDateTime");

+    }

+

+private:

+    mutable MamaDateTime mDateTime;

+};

+

+

+/**

+ * MamaFieldCacheFieldVectorBasic.

+ * Base class for basic vector types. Allows to set and get the value of the field.

+ */

+template <typename T, mamaFieldType fieldType>

+class MAMACPPExpDLL MamaFieldCacheFieldVectorBasic : public MamaFieldCacheFieldBase

+{

+public:

+    /**

+     * Set the field value.

+     *

+     * @param field The field to set the values to.

+     * @param values The new values of the field.

+     * @param size The number of fields in <code>values</code>.

+     */

+    void set(MamaFieldCacheField& field, const T* values, mama_size_t size);

+    /**

+     * Return the field values.

+     *

+     * @param field The field to get the values from.

+     * @param values A reference to the values to be returned.

+     * @param size A reference to the size of the vector to be returned.

+     */

+    void get(const MamaFieldCacheField& field, const T*& values, mama_size_t& size) const;

+    /**

+     * Return the value of a specific field of a vector field.

+     *

+     * @param field The field to get the value from.

+     * @param index The index of the element of the vector to get the value from.

+     * @return The value of the field.

+     */

+    const T& get(const MamaFieldCacheField& field, mama_size_t index) const;

+   

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != fieldType)

+            throw std::invalid_argument("MamaFieldCacheFieldVectorBasic");

+    }

+};

+

+/**

+ * MamaFieldCacheFieldI8Vector.

+ * Class used to set and get the value of a mama_i8_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_i8_t, MAMA_FIELD_TYPE_VECTOR_I8>

+    MamaFieldCacheFieldI8Vector;

+/**

+ * MamaFieldCacheFieldU8Vector.

+ * Class used to set and get the value of a mama_u8_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_u8_t, MAMA_FIELD_TYPE_VECTOR_U8>

+    MamaFieldCacheFieldU8Vector;

+/**

+ * MamaFieldCacheFieldI16Vector.

+ * Class used to set and get the value of a mama_i16_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_i16_t, MAMA_FIELD_TYPE_VECTOR_I16>

+    MamaFieldCacheFieldI16Vector;

+/**

+ * MamaFieldCacheFieldU16Vector.

+ * Class used to set and get the value of a mama_u16_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_u16_t, MAMA_FIELD_TYPE_VECTOR_U16>

+    MamaFieldCacheFieldU16Vector;

+/**

+ * MamaFieldCacheFieldI32Vector.

+ * Class used to set and get the value of a mama_i32_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_i32_t, MAMA_FIELD_TYPE_VECTOR_I32>

+    MamaFieldCacheFieldI32Vector;

+/**

+ * MamaFieldCacheFieldU32Vector.

+ * Class used to set and get the value of a mama_u32_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_u32_t, MAMA_FIELD_TYPE_VECTOR_U32>

+    MamaFieldCacheFieldU32Vector;

+/**

+ * MamaFieldCacheFieldI64Vector.

+ * Class used to set and get the value of a mama_i64_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_i64_t, MAMA_FIELD_TYPE_VECTOR_I64>

+    MamaFieldCacheFieldI64Vector;

+/**

+ * MamaFieldCacheFieldU64Vector.

+ * Class used to set and get the value of a mama_u64_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_u64_t, MAMA_FIELD_TYPE_VECTOR_U64>

+    MamaFieldCacheFieldU64Vector;

+/**

+ * MamaFieldCacheFieldF32Vector.

+ * Class used to set and get the value of a mama_f32_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_f32_t, MAMA_FIELD_TYPE_VECTOR_F32>

+    MamaFieldCacheFieldF32Vector;

+/**

+ * MamaFieldCacheFieldF64Vector.

+ * Class used to set and get the value of a mama_f64_t vector <code>MamaFieldCacheField</code>.

+ */

+typedef MamaFieldCacheFieldVectorBasic<mama_f64_t, MAMA_FIELD_TYPE_VECTOR_F64>

+    MamaFieldCacheFieldF64Vector;

+

+

+// Special vector types

+/**

+ * MamaFieldCacheField: String vector field

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldStringVector

+    : public MamaFieldCacheFieldBase

+{

+public:

+    /**

+     * Set the values of a string vector field.

+     *

+     * @param field The field to set the values to.

+     * @param values The new values of the field.

+     * @param size The number of fields in <code>values</code>.

+     */

+    void set(MamaFieldCacheField& field, const char** values, mama_size_t size);

+    /**

+     * Return the values of a string vector.

+     *

+     * @param field The field to get the values from.

+     * @param values A reference to the values to be returned.

+     * @param size A reference to the size of the vector to be returned.

+     */

+    void get(const MamaFieldCacheField& field, const char**& values, mama_size_t& size) const;

+    /**

+     * Return the value of a specific field of a string vector field.

+     *

+     * @param field The field to get the value from.

+     * @param index The index of the element of the vector to get the value from.

+     * @return The value of the field.

+     */

+    const char* get(const MamaFieldCacheField& field, mama_size_t index) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != MAMA_FIELD_TYPE_VECTOR_STRING)

+            throw std::invalid_argument("MamaFieldCacheFieldStringVector");

+    }

+};

+

+

+template <typename T>

+class MamaFieldCacheFieldVector

+{

+protected:

+    MamaFieldCacheFieldVector()

+        : mValues(NULL)

+        , mSize(0)

+    {

+    }

+    ~MamaFieldCacheFieldVector()

+    {

+        if (!mValues || !mSize)

+        {

+            return;

+        }

+        delete[] mValues;

+    }

+

+    void grow(mama_size_t newSize) const

+    {

+        if (newSize <= mSize)

+            return;

+

+        T* newVector = new T[newSize];

+        for (mama_size_t i = 0; i < mSize; ++i)

+        {

+            newVector[i] = mValues[i];

+        }

+

+        if (mValues)

+            delete[] mValues;

+

+        mValues = newVector;

+        mSize = newSize;

+    }

+

+protected:

+    mutable T* mValues;

+    mutable mama_size_t mSize;

+};

+

+/**

+ * MamaFieldCacheField: Price vector field

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldPriceVector

+    : public MamaFieldCacheFieldBase

+    , public MamaFieldCacheFieldVector<MamaPrice>

+{

+public:

+    /**

+     * Set the values of a MamaPrice vector field.

+     *

+     * @param field The field to set the values to.

+     * @param values The new values of the field.

+     * @param size The number of fields in <code>values</code>.

+     */

+    void set(MamaFieldCacheField& field, const MamaPrice* values, mama_size_t size);

+    /**

+     * Return the values of a MamaPrice vector field.

+     *

+     * @param field The field to get the values from.

+     * @param values A reference to the values to be returned.

+     * @param size A reference to the size of the vector to be returned.

+     */

+    void get(const MamaFieldCacheField& field, const MamaPrice*& values, mama_size_t& size) const;

+    /**

+     * Return the value of a specific field of a MamaPrice vector field.

+     *

+     * @param field The field to get the value from.

+     * @param index The index of the element of the vector to get the value from.

+     * @return The value of the field.

+     */

+    const MamaPrice* get(const MamaFieldCacheField& field, mama_size_t index) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != MAMA_FIELD_TYPE_VECTOR_PRICE)

+            throw std::invalid_argument("MamaFieldCacheFieldPriceVector");

+    }

+

+private:

+    mutable MamaPrice mValue;

+};

+

+/**

+ * MamaFieldCacheField: DateTime vector field

+ */

+class MAMACPPExpDLL MamaFieldCacheFieldDateTimeVector

+    : public MamaFieldCacheFieldBase

+    , public MamaFieldCacheFieldVector<MamaDateTime>

+{

+public:

+    /**

+     * Set the values of MamDateTime vector field.

+     *

+     * @param field The field to set the values to.

+     * @param values The new values of the field.

+     * @param size The number of fields in <code>values</code>.

+     */

+    void set(MamaFieldCacheField& field, const MamaDateTime* values, mama_size_t size);

+    /**

+     * Return the values of a MamaDateTime vector field.

+     *

+     * @param field The field to get the values from.

+     * @param values A reference to the values to be returned.

+     * @param size A reference to the size of the vector to be returned.

+     */

+    void get(const MamaFieldCacheField& field, const MamaDateTime*& values, mama_size_t& size) const;

+    /**

+     * Return the value of a specific field of a MamaDateTime vector field.

+     *

+     * @param field The field to get the value from.

+     * @param index The index of the element of the vector to get the value from.

+     * @return The value of the field.

+     */

+    const MamaDateTime* get(const MamaFieldCacheField& field, mama_size_t index) const;

+

+protected:

+    void checkType(const MamaFieldCacheField& field) const

+    {

+        if (field.getType() != MAMA_FIELD_TYPE_VECTOR_TIME)

+            throw std::invalid_argument("MamaFieldCacheFieldTimeVector");

+    }

+

+private:

+    mutable MamaDateTime mValue;

+};

+

+

+/**

+ * Helper function to set the value of a String field.

+ *

+ * @param field The field to set the value to.

+ * @param value The value to set.

+ */

+void setFieldValue(MamaFieldCacheField& field, const char* value);

+

+/**

+ * Helper function to set the value of a MamaPrice field.

+ *

+ * @param field The field to set the value to.

+ * @param value The value to set.

+ */

+void setFieldValue(MamaFieldCacheField& field, const MamaPrice& value);

+

+/**

+ * Helper function to set the value of a MamaDateTime field.

+ *

+ * @param field The field to set the value to.

+ * @param value The value to set.

+ */

+void setFieldValue(MamaFieldCacheField& field, const MamaDateTime& value);

+

+/*

+template <class Field, class Value>

+void setFieldValue(MamaFieldCacheField& field, const Value& value)

+{

+    Field setField;

+    setField.set(field, value);

+}

+*/

+

+template <mamaFieldType fieldType>

+class Type

+{

+};

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_CHAR> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldChar setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_BOOL> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldBool setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_I8> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldI8 setField;

+    setField.set(field, value);

+}

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_U8> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldU8 setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_I16> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldI16 setField;

+    setField.set(field, value);

+}

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_U16> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldU16 setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_I32> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldI32 setField;

+    setField.set(field, value);

+}

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_U32> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldU32 setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_I64>, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldI64 setField;

+    setField.set(field, value);

+}

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_U64> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldU64 setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_F32> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldF32 setField;

+    setField.set(field, value);

+}

+template <typename T>

+void setV(Type<MAMA_FIELD_TYPE_F64> type, MamaFieldCacheField& field, const T& value)

+{

+    MamaFieldCacheFieldF64 setField;

+    setField.set(field, value);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_CHAR> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldChar getField;

+    value = getField.get(field);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_BOOL> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldBool getField;

+    value = getField.get(field);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_I8> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldI8 getField;

+    value = getField.get(field);

+}

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_U8> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldU8 getField;

+    value = getField.get(field);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_I16> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldI16 getField;

+    value = getField.get(field);

+}

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_U16> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldU16 getField;

+    value = getField.get(field);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_I32> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldI32 getField;

+    value = getField.get(field);

+}

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_U32> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldU32 getField;

+    value = getField.get(field);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_I64> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldI64 getField;

+    value = getField.get(field);

+}

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_U64> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldU64 getField;

+    value = getField.get(field);

+}

+

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_F32> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldF32 getField;

+    value = getField.get(field);

+}

+template <typename T>

+void getV(Type<MAMA_FIELD_TYPE_F64> type, const MamaFieldCacheField& field, T& value)

+{

+    MamaFieldCacheFieldF64 getField;

+    value = getField.get(field);

+}

+

+/**

+ * Helper function to set the value of a generic single-value field.

+ *

+ * @param field The field to set the value to.

+ * @param value The value to set.

+ */

+template <typename T>

+void setFieldValue(MamaFieldCacheField& field, const T& value)

+{

+    switch(field.getType())

+    {

+        case MAMA_FIELD_TYPE_CHAR:

+        {

+            setV(Type<MAMA_FIELD_TYPE_CHAR>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_BOOL:

+        {

+            setV(Type<MAMA_FIELD_TYPE_BOOL>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I8:

+        {

+            setV(Type<MAMA_FIELD_TYPE_I8>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U8:

+        {

+            setV(Type<MAMA_FIELD_TYPE_U8>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I16:

+        {

+            setV(Type<MAMA_FIELD_TYPE_I16>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U16:

+        {

+            setV(Type<MAMA_FIELD_TYPE_U16>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I32:

+        {

+            setV(Type<MAMA_FIELD_TYPE_I32>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U32:

+        {

+            setV(Type<MAMA_FIELD_TYPE_U32>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I64:

+        {

+            setV(Type<MAMA_FIELD_TYPE_I64>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U64:

+        {

+            setV(Type<MAMA_FIELD_TYPE_U64>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F32:

+        {

+            setV(Type<MAMA_FIELD_TYPE_F32>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F64:

+        {

+            setV(Type<MAMA_FIELD_TYPE_F64>(), field, value);

+            break;

+        }

+        default:

+            break;

+    }

+}

+

+/**

+ * Helper function to get the value of a string field.

+ *

+ * @param field The field to get the value from.

+ * @param value The value to return.

+ */

+void getFieldValue(const MamaFieldCacheField& field, const char*& value);

+

+/**

+ * Helper function to get the value of a MamaPrice field.

+ *

+ * @param field The field to get the value from.

+ * @param value The value to return.

+ */

+void getFieldValue(const MamaFieldCacheField& field, MamaPrice& value);

+

+/**

+ * Helper function to get the value of a MamaDateTime field.

+ *

+ * @param field The field to get the value from.

+ * @param value The value to return.

+ */

+void getFieldValue(const MamaFieldCacheField& field, MamaDateTime& value);

+

+/**

+ * Helper function to get the value of a generic single-value field.

+ *

+ * @param field The field to get the value from.

+ * @param value The value to return.

+ */

+template <typename T>

+void getFieldValue(const MamaFieldCacheField& field, T& value)

+{

+    switch(field.getType())

+    {

+        case MAMA_FIELD_TYPE_CHAR:

+        {

+            getV(Type<MAMA_FIELD_TYPE_CHAR>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_BOOL:

+        {

+            getV(Type<MAMA_FIELD_TYPE_BOOL>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I8:

+        {

+            getV(Type<MAMA_FIELD_TYPE_I8>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U8:

+        {

+            getV(Type<MAMA_FIELD_TYPE_U8>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I16:

+        {

+            getV(Type<MAMA_FIELD_TYPE_I16>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U16:

+        {

+            getV(Type<MAMA_FIELD_TYPE_U16>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I32:

+        {

+            getV(Type<MAMA_FIELD_TYPE_I32>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U32:

+        {

+            getV(Type<MAMA_FIELD_TYPE_U32>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_I64:

+        {

+            getV(Type<MAMA_FIELD_TYPE_I64>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_U64:

+        {

+            getV(Type<MAMA_FIELD_TYPE_U64>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F32:

+        {

+            getV(Type<MAMA_FIELD_TYPE_F32>(), field, value);

+            break;

+        }

+        case MAMA_FIELD_TYPE_F64:

+        {

+            getV(Type<MAMA_FIELD_TYPE_F64>(), field, value);

+            break;

+        }

+        default:

+            break;

+    }

+}

+

+/**

+ * Helper function to set the values of a generic vector field.

+ *

+ * @param field The field to set the values to.

+ * @param values The values to set.

+ * @param size The number of values in the field.

+ */

+template <typename T>

+void setFieldValue(MamaFieldCacheField& field, const T* values, mama_size_t size)

+{

+    switch(field.getType())

+    {

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        {

+            MamaFieldCacheFieldI8Vector getField;

+            getField.set(field, (const mama_i8_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        {

+            MamaFieldCacheFieldU8Vector getField;

+            getField.set(field, (const mama_u8_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        {

+            MamaFieldCacheFieldI16Vector getField;

+            getField.set(field, (const mama_i16_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        {

+            MamaFieldCacheFieldU16Vector getField;

+            getField.set(field, (const mama_u16_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        {

+            MamaFieldCacheFieldI32Vector getField;

+            getField.set(field, (const mama_i32_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        {

+            MamaFieldCacheFieldU32Vector getField;

+            getField.set(field, (const mama_u32_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        {

+            MamaFieldCacheFieldI64Vector getField;

+            getField.set(field, (const mama_i64_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        {

+            MamaFieldCacheFieldU64Vector getField;

+            getField.set(field, (const mama_u64_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F32:

+        {

+            MamaFieldCacheFieldF32Vector getField;

+            getField.set(field, (const mama_f32_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F64:

+        {

+            MamaFieldCacheFieldF64Vector getField;

+            getField.set(field, (const mama_f64_t*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+        {

+            MamaFieldCacheFieldStringVector getField;

+            getField.set(field, (const char**)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_PRICE:

+        {

+            MamaFieldCacheFieldPriceVector getField;

+            getField.set(field, (const MamaPrice*)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_TIME:

+        {

+            MamaFieldCacheFieldDateTimeVector getField;

+            getField.set(field, (const MamaDateTime*)values, size);

+            break;

+        }

+        default:

+            break;

+    }

+}

+

+/**

+ * Helper function to set the values of a string vector field.

+ *

+ * @param field The field to set the values to.

+ * @param values The values to set.

+ * @param size The number of values in the field.

+ */

+void getFieldValue(const MamaFieldCacheField& field, const char**& values, mama_size_t& size);

+

+// TODO: NOT IMPLEMENTED YET

+// Need to fix the C++ MamaPrice and MamaDateTime interface to allow replacing

+// the inner C structure (otherwise a copy is needed causing either a memory leak

+// or an early delete.

+void getFieldValue(const MamaFieldCacheField& field, const MamaPrice*& values, mama_size_t& size);

+

+void getFieldValue(const MamaFieldCacheField& field, const mamaDateTime*& values, mama_size_t& size);

+

+/**

+ * Helper function to get the values of a generic vector field.

+ *

+ * @param field The field to get the values from.

+ * @param values The values to return.

+ * @param size The number of values in the field.

+ */

+template <typename T>

+void getFieldValue(const MamaFieldCacheField& field, const T*& values, mama_size_t& size)

+{

+    switch(field.getType())

+    {

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        {

+            MamaFieldCacheFieldI8Vector getField;

+            getField.get(field, (const mama_i8_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        {

+            MamaFieldCacheFieldU8Vector getField;

+            getField.get(field, (const mama_u8_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        {

+            MamaFieldCacheFieldI16Vector getField;

+            getField.get(field, (const mama_i16_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        {

+            MamaFieldCacheFieldU16Vector getField;

+            getField.get(field, (const mama_u16_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        {

+            MamaFieldCacheFieldI32Vector getField;

+            getField.get(field, (const mama_i32_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        {

+            MamaFieldCacheFieldU32Vector getField;

+            getField.get(field, (const mama_u32_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        {

+            MamaFieldCacheFieldI64Vector getField;

+            getField.get(field, (const mama_i64_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        {

+            MamaFieldCacheFieldU64Vector getField;

+            getField.get(field, (const mama_u64_t*&)values, size);

+            break;

+        }        

+        case MAMA_FIELD_TYPE_VECTOR_F32:

+        {

+            MamaFieldCacheFieldF32Vector getField;

+            getField.get(field, (const mama_f32_t*&)values, size);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F64:

+        {

+            MamaFieldCacheFieldF64Vector getField;

+            getField.get(field, (const mama_f64_t*&)values, size);

+            break;

+        }

+        default:

+            break;

+    }

+}

+

+void mamaFieldCacheFieldFromString(MamaFieldCacheField& field, const std::string& value);

+

+} // namespace Wombat

+

+#endif // MAMA_FIELD_CACHE_FIELD_TYPES_CPP_H__

diff --git a/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheRecord.h b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheRecord.h

new file mode 100644

index 0000000..0ee6bd0

--- /dev/null

+++ b/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheRecord.h

@@ -0,0 +1,130 @@

+/* $Id: //commsof_depot/platform/products/6.0/trunk/mama/c_cpp/src/cpp/mama/fieldcache/MamaFieldCacheRecord.h#1 $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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 MAMA_FIELD_CACHE_RECORD_CPP_H__

+#define MAMA_FIELD_CACHE_RECORD_CPP_H__

+

+#include <mama/mamacpp.h>

+#include <mama/fieldcache/fieldcachetypes.h>

+#include <string>

+

+namespace Wombat

+{

+

+    class MamaFieldCacheField;

+

+/**

+ * The <code>MamaFieldCacheRecord</code> class is a collection of unordered

+ * <code>MamaFieldCacheField</code> elements.

+ */

+class MAMACPPExpDLL MamaFieldCacheRecord

+{

+public:

+    /**

+     * Constructor.

+     * Use <code>create</code> to create the actual cache.

+     */

+    MamaFieldCacheRecord();

+    /**

+     * Destructor.

+     * This is called automatically when an object is destroyed. This method will

+     * clean all the memory allocated.

+     */

+    virtual ~MamaFieldCacheRecord();

+   

+    /**

+     * Creates a <code>MamaFieldCacheRecord</code>.

+     */

+    virtual void create();

+   

+    /**

+     * Clear the <code>MamaFieldCacheRecord</code>.

+     * No fields will be present in the record after this operation. The record is

+     * ready to be used, as long as create has been called once.

+     */

+    virtual void clear();

+   

+    /**

+     * Add and creates a <code>MamaFieldCacheField</code> to the record.

+     * The new field is then returned.

+     *

+     * @param fid Field id of the field to create.

+     * @param type Field type of the field to create.

+     * @param name Name of the field to create.

+     * @return The new field created.

+     */

+    virtual MamaFieldCacheField& add(mama_fid_t fid,

+                                     mamaFieldType type,

+                                     const char* name = NULL);

+   

+    /**

+     * Add and creates a <code>MamaFieldCacheField</code> to the record.

+     * The new field is then returned.

+     *

+     * @param descriptor Descriptor of the field to create.

+     * @return The new field created.

+     */

+    virtual MamaFieldCacheField& add(const MamaFieldDescriptor& descriptor);

+

+   

+    virtual const MamaFieldCacheField& operator[](mama_size_t index) const;

+    virtual MamaFieldCacheField& operator[](mama_size_t index);

+   

+    /**

+     * Find a <code>MamaFieldCacheField</code> in the record.

+     *

+     * @param fid Field id of the field to look up.

+     * @param name Field name of the field to look up.

+     * @return The field in the record.

+     */

+    virtual const MamaFieldCacheField& find(mama_fid_t fid,

+                                            const char* name = NULL) const;

+   

+    /**

+     * Find a <code>MamaFieldCacheField</code> in the record.

+     *

+     * @param fid Field id of the field to look up.

+     * @param name Field name of the field to look up.

+     * @return The field in the record.

+     */

+    virtual MamaFieldCacheField& find(mama_fid_t fid, const char* name = NULL);

+    /**

+     * Return the number of fields present in the record.

+     *

+     * @return Size of the record.

+     */

+    virtual mama_size_t getSize() const;

+   

+    virtual mamaFieldCacheRecord getCValue();

+    virtual const mamaFieldCacheRecord getCValue() const;

+   

+private:

+    MamaFieldCacheRecord(const MamaFieldCacheRecord&);

+    MamaFieldCacheRecord& operator=(const MamaFieldCacheRecord&);

+

+private:

+    struct MamaFieldCacheRecordImpl;

+    MamaFieldCacheRecordImpl* mPimpl;

+};

+

+} // namespace Wombat

+

+#endif

diff --git a/mama/c_cpp/src/cpp/mamacpp.vcproj b/mama/c_cpp/src/cpp/mamacpp.vcproj

index 89dd2f5..7b6e5dd 100644

--- a/mama/c_cpp/src/cpp/mamacpp.vcproj

+++ b/mama/c_cpp/src/cpp/mamacpp.vcproj

@@ -518,6 +518,22 @@

                                                               >

                                               </File>

                                               <File

+                                                             RelativePath=".\mama\fieldcache\MamaFieldCacheField.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\MamaFieldCacheFieldTypes.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\MamaFieldCache.h"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\mama\fieldcache\MamaFieldCacheRecord.h"

+                                                             >

+                                             </File>

+                                             <File

                                                               RelativePath=".\mama\MamaSource.h"

                                                               >

                                               </File>

@@ -654,6 +670,22 @@

                                                               >

                                               </File>

                                               <File

+                                                             RelativePath=".\fieldcache\MamaFieldCache.cpp"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\MamaFieldCacheField.cpp"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\MamaFieldCacheFieldTypes.cpp"

+                                                             >

+                                             </File>

+                                             <File

+                                                             RelativePath=".\fieldcache\MamaFieldCacheRecord.cpp"

+                                                             >

+                                             </File>

+                                             <File

                                                               RelativePath=".\mamacpp.cpp"

                                                               >

                                               </File>

diff --git a/mama/c_cpp/src/examples/c/Makefile.am b/mama/c_cpp/src/examples/c/Makefile.am

index e348415..ebaaae8 100644

--- a/mama/c_cpp/src/examples/c/Makefile.am

+++ b/mama/c_cpp/src/examples/c/Makefile.am

@@ -49,7 +49,8 @@ bin_PROGRAMS =  mamalistenc \

                 mamaio \

                 mamamultisubscriberc \

                 mamaftmemberc \

-                                                              mamasymbollistsubscriberc

+                                                             mamasymbollistsubscriberc \

+                                                             mamalistencachedc

 

 dist_mamalistenc_SOURCES                      = mamalistenc.c    

 dist_mamaproxyc_SOURCES                                     = mamaproxyc.c

@@ -60,6 +61,7 @@ dist_mamaio_SOURCES                      = mamaio.c

dist_mamasymbollistsubscriberc_SOURCES       = mamasymbollistsubscriberc.c

dist_mamamultisubscriberc_SOURCES                     = mamamultisubscriberc.c

dist_mamaftmemberc_SOURCES                                            = mamaftmemberc.c

+dist_mamalistencachedc_SOURCES                      = mamalistencachedc.c

 

 # Additional installation directory for sample source code

exampledir = ${prefix}/examples/mama/c

@@ -76,4 +78,5 @@ example_DATA = \

         $(dist_mamainboxc_SOURCES) \

         $(dist_mamaio_SOURCES) \

                               $(dist_mamasymbollistsubscriberc_SOURCES) \

+                             $(dist_mamalistencachedc_SOURCES) \

                                Makefile.sample

diff --git a/mama/c_cpp/src/examples/c/Makefile.sample b/mama/c_cpp/src/examples/c/Makefile.sample

index 6f2507d..092efae 100644

--- a/mama/c_cpp/src/examples/c/Makefile.sample

+++ b/mama/c_cpp/src/examples/c/Makefile.sample

@@ -47,7 +47,8 @@ all: mamalistenc mamainboxc \

                mamapublisherc mamasubscriberc \

                mamasymbollistsubscriberc \

               mamaproxyc mamaio \

-              mamamultisubscriberc mamaftmemberc

+             mamamultisubscriberc mamaftmemberc \

+             mamalistencachedc

    

 mamalistenc: mamalistenc.o

               $(LINK.C) -o $@ $^ $(MAMA_LIBS) $(SYS_LIBS)

@@ -75,3 +76,7 @@ mamasymbollistsubscriberc: mamasymbollistsubscriberc.o

 

 mamaftmemberc: mamaftmemberc.o

               $(LINK.C) -o $@ $^ $(MAMA_LIBS) $(SYS_LIBS)

+

+mamalistencachedc: mamalistencachedc.o

+             $(LINK.C) -o $@ $^ $(MAMA_LIBS) $(SYS_LIBS)

+

diff --git a/mama/c_cpp/src/examples/c/SConscript b/mama/c_cpp/src/examples/c/SConscript

index 154c801..694a5e5 100644

--- a/mama/c_cpp/src/examples/c/SConscript

+++ b/mama/c_cpp/src/examples/c/SConscript

@@ -18,7 +18,8 @@ env.Append( LIBPATH = libPath )

env.Append( CPPPATH = [ includePath ] )

env.Append( LIBS = [ 'mama','pthread','m','wombatcommon','rt' ] )

 

-bins = [ 'mamalistenc','mamaproxyc','mamapublisherc','mamasubscriberc','mamainboxc','mamaio','mamasymbollistsubscriberc','mamamultisubscriberc','mamaftmemberc','mamasymbollistsubscriberc' ]

+bins = [ 'mamalistenc','mamaproxyc','mamapublisherc','mamasubscriberc','mamainboxc','mamaio','mamasymbollistsubscriberc','mamamultisubscriberc','mamaftmemberc','mamasymbollistsubscriberc',

+'mamalistencachedc' ]

 

 binary = []

 

diff --git a/mama/c_cpp/src/examples/c/SConscript.win b/mama/c_cpp/src/examples/c/SConscript.win

index 156c624..77ac387 100644

--- a/mama/c_cpp/src/examples/c/SConscript.win

+++ b/mama/c_cpp/src/examples/c/SConscript.win

@@ -14,6 +14,7 @@ binaries = Split("""

               mamaproxyc

               mamasubscriberc

               mamasymbollistsubscriberc

+             mamalistencachedc

""")

 

 libs = []

diff --git a/mama/c_cpp/src/examples/c/mamalistencachedc.c b/mama/c_cpp/src/examples/c/mamalistencachedc.c

new file mode 100644

index 0000000..abf0efb

--- /dev/null

+++ b/mama/c_cpp/src/examples/c/mamalistencachedc.c

@@ -0,0 +1,2839 @@

+/* $Id: mamalistencachedc.c,v 1.1.2.19 2012/04/16 10:56:24 gmolloy Exp $

+ *

+ * OpenMAMA: The open middleware agnostic messaging API

+ * Copyright (C) 2011 NYSE Technologies, Inc.

+ *

+ * 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.

+ *

+ * 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

+ *

+ *

+ * mamalistencachedc - Example Mama API market data subscriber.

+ *

+ * <pre>

+ * Illustrates the following MAMA API features:

+ *   1. Data dictionary initialization.

+ *   2. Creating a transport.

+ *   3. Creating different types of subscriptions (Snapshot, group etc)

+ *   4. Walking all received fields in messages.

+ *   5  Displaying only specific fields in a message.

+ *

+ * Examples:

+ *

+ * 1. Display data dictionary with dictionary requested from source

+ *    "ORDER" (default dictionary symbol name space is "WOMBAT" and

+ *    used in subsequent examples, below).

+ *

+ *    mamalistencahedc -S ORDER -D -d ORDER -s MSFT.ISLD -tport tport_name

+ *

+ * 2. Subscribing to top-of-book MSFT quote from Island ITCH feed (all

+ *    fields) where the feed handler source is SOURCE:

+ *

+ *    mamalistencachedc -S ORDER -s MSFT.ISLD -tport tport_name

+ *

+ * 3. Subscribing to top-of-book MSFT & ORCL from Island ITCH feed

+ *    (specific fields):

+ *

+ *    mamalistencachedc -S ORDER -s MSFT.ISLD -s MSFT.ISLD wBidPrice wBidSize wAskPrice

+ *

+ * 4. Subscribing to a list of symbols from a file (all fields) and

+ *    report updates quietly (an additional -q would eliminate printing

+ *    of all normal updates):

+ *

+ *    mamalistencachedc -q -f file -tport tport_name

+ *

+ * <pre>

+ *

+ */

+

+#include "wombat/port.h"

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <string.h>

+#include <signal.h>

+

+#include <mama/mama.h>

+#include <mama/marketdata.h>

+#include <mama/transport.h>

+#include <mama/msgstatus.h>

+#include <mama/status.h>

+#include <mama/timer.h>

+#include <mama/symbolmapfile.h>

+#include <mama/fieldcache/fieldcache.h>

+#include <mama/fieldcache/fieldcachefield.h>

+#include <mama/fieldcache/fieldcacheiterator.h>

+

+#define MAX_FIELDS 1000

+#define MAX_SUBSCRIPTIONS 250000

+

+static char *gUsageString[] =

+{

+"Example Mama API market data subscriber, which stores fields using a MamaFieldCache.",

+"",

+"Usage: mamalistenachedc -S symbolNameSpace [-s symbol | -f symbolFile]",

+"                  [-tport transportName] [-dict_tport transportName]",

+"                  [-d dictSymbolNameSpace] [-vDgE?IL1qWB] [-DF fileName]",

+"                  [-hw highWaterMark] [-lw lowWaterMark]",

+"                  [-threads numThreads] [-r throttleRate]",

+"                  [-t subscriptionTimeout] [-version (requires -m)] [-m middleware]",

+"",

+"Options:",

+"All the standard mamalistenc options are available, plus the following:",

+"  -verifyCache    verifies the content of the cache against the message received.",

+"  -verifyInterval changes the interval used for verification, (default 5s).",

+"  -no_display      will not print out any field data.",

+"  -printCache     Print content of the cache after printing the generated message.",

+"",

+NULL

+};

+

+

+/* This structure is used when verifying data held in the field cache

+ * against a snapshot image of a subscription.

+ */

+typedef struct VerificationData

+{

+    /* The queue the subscription was created on. */   

+    mamaQueue m_queue;

+

+    /* The symbol name. */

+    const char *m_symbol;

+

+    /* The timer being used to verify the data. */

+    mamaTimer m_timer;

+   

+    /* The index of the subscription/cache */

+    int mIndex;

+

+} VerificationData, * PVerificationData;

+

+/* These members represent command line parameters detailed in the gUsageString above. */

+static int      gVerifyCache        = 0;

+static double   gVerifyInterval     = 5.0;

+static int      gNoDisplay          = 0;

+static int      gPrintCache         = 0;

+

+/* There must be 1 field cache per symbol. */

+static mamaFieldCache *gFieldCaches = NULL;

+static int *gFieldCacheIndexes = NULL;

+

+static mamaTransport     gTransport          = 0 ;

+static long              gThrottle           = -1;

+static long              gRecapThrottle      = -1;

+static int               gMsgCount           = 0;

+static long              gNumMsg             = 0;

+static long              gNumMsgLast         = 0;

+       long              gTotalMsg           = 0;

+static int               gInterval           = 2;

+static int               gThreads            = 0;

+static int               gHasCreatedThreads  = 0;

+static int               gQualityForAll      = 1;

+static mamaQueue*        gQueues             = NULL;

+static mamaDispatcher*   gDispatchers        = NULL;

+

+static const char*       gTport              = NULL;

+

+static const char*       gDictTport          = NULL;

+static mamaTransport     gDictTransport      = NULL;

+

+static mamaDictionary    gDictionary;

+static const char*       gDictSymbolNamespace  = "WOMBAT";

+static int               gDumpDataDict       = 0;

+static int               gDictToFile         = 0;

+static int               gDictFromFile         = 0;

+static const char*       gDictFile           = NULL;

+static int               gBuildDataDict      = 1;

+static int               gExtractData        = 1;

+

+static const char**      gFieldList          = NULL;

+static int               gNumFields          = 0;

+

+static int               gDictionaryComplete = 0;

+

+static int               gGroupSubscription  = 0;

+static int               gRequireInitial     = 1;

+static int               gSnapshot           = 0;

+static double            gTimeout            = 10.0;

+static int               gQuietness          = 0;

+static int               gPrintVersionAndExit= 0;

+

+static mamaSubscription* gSubscriptionList   = NULL;

+

+static int               gNumSubscriptions   = 0;

+static const char**      gSymbolList         = NULL;

+static int               gNumSymbols         = 0;

+static MamaLogLevel      gSubscLogLevel      = MAMA_LOG_LEVEL_NORMAL;

+static const char*       gFilename           = NULL;

+static const char*       gMapFilename        = NULL;

+static mamaSymbolMapFile gSymbolMapFromFile  = NULL;

+

+static int               gNewIterators       = 0;

+static const char*       gSymbolNamespace    = NULL;

+static mamaSource        gSubscriptionSource = NULL;

+static mamaSource        gDictSource         = NULL;

+static const char*       gMiddleware         = "wmw";

+static mamaBridge        gMamaBridge         = NULL;

+static mamaQueue         gMamaDefaultQueue   = NULL;

+static const char*       gAppName            = NULL;

+static size_t            gHighWaterMark      = 0;

+static size_t            gLowWaterMark       = 0;

+

+

+/* Contains the amount of time that the example program will run for, if set to 0 then it

+ * will run indefinitely.

+ */

+static int                                                            gShutdownTime                              = 0;

+

+

+static void parseCommandLine    (int argc, const char* argv[]);

+static void initializeMama      (void);

+

+static void buildDataDictionary (void);

+static void dumpDataDictionary  (void);

+static void loadSymbolMap       (void);

+static void readSymbolsFromFile (void);

+static void subscribeToSymbols  (void);

+static void mamashutdown            (void);

+static void setQueueMonitors    (mamaQueue queue, int queueIndex);

+static FILE* gLogFile = NULL;

+

+static void MAMACALLTYPE

+subscriptionOnMsg   (mamaSubscription    subscription,

+                     mamaMsg             msg,

+                     void*               closure,

+                     void*               itemClosure);

+static void MAMACALLTYPE

+subscriptionOnQuality (mamaSubscription subsc,

+                       mamaQuality      quality,

+                       const char*      symbol,

+                       short            cause,

+                       const void*      platformInfo,

+                       void*            closure);

+

+static void MAMACALLTYPE

+subscriptionOnError (mamaSubscription    subscription,

+                     mama_status         status,

+                     void*               platformError,

+                     const char*         subject,

+                     void*               closure);

+static void MAMACALLTYPE

+subscriptionOnCreate (mamaSubscription    subscription,

+                      void*               closure);

+

+static void displayFields       (mamaMsg             msg,

+                                 mamaSubscription    subscription);

+static void displaySpecificField(mamaFieldDescriptor field,

+                                 mamaMsg             msg);

+static void displayField        (mamaMsgField        field,

+                                 const mamaMsg       msg,

+                                 int                 indentLevel);

+static void displayAllFields    (mamaMsg             msg,

+                                 mamaSubscription    subscription,

+                                 int                 indentLevel);

+

+static void MAMACALLTYPE

+rateReporterCallback       (mamaTimer           timer,

+                            void *              closure);

+

+static void MAMACALLTYPE

+timeoutCb                  (mamaDictionary      dict,

+                            void *              closure);

+static void MAMACALLTYPE

+errorCb                    (mamaDictionary      dict,

+                            const char *        errMsg,

+                            void *              closure);

+static void MAMACALLTYPE

+completeCb                 (mamaDictionary      dict,

+                            void *              closure);

+

+static void MAMACALLTYPE

+displayCb                  (const mamaMsg       msg,

+                            const mamaMsgField  field,

+                            void *              closure);

+

+/*Callback for event queue high watermark monitoring.*/

+static void MAMACALLTYPE

+highWaterMarkCallback (mamaQueue     queue,

+                       size_t        size,

+                       void*         closure);

+

+/*Callback for event queue low watermark monitoring.*/

+static void MAMACALLTYPE

+lowWaterMarkCallback  (mamaQueue     queue,

+                       size_t        size,

+                       void*         closure);

+

+static void MAMACALLTYPE

+shutdownTimerCallback(mamaTimer timer, void *closure)

+{

+             /* Stop dispatching messages. */

+             mama_stop(gMamaBridge);

+}

+

+                       

+void usage                 (int                 exitStatus);

+

+

+static void MAMACALLTYPE

+verifyTimerCallback(mamaTimer timer, void *closure);

+

+/* Function Prototypes. */

+mama_status checkFieldIntegrityIds(mamaMsgField field, mamaFieldCache fieldCache, int *test);

+mama_status checkSnapshotIntegrity(mamaFieldCache fieldCache, mamaMsg message);

+mama_status createFieldCaches(void);

+mama_status createVerificationTimer(mamaQueue queue, const char *symbol, int index);

+mama_status destroyFieldCaches(void);

+void        destroyVerificationTimer(PVerificationData data);

+mama_status displayHeader(mamaMsg message, mamaSubscription subscription);

+/*

+mama_status getFieldAsString(char *buffer, long bufferLength, mamaMsgField field, mamaFieldType type);

+*/

+mama_status printAllCacheFields(mamaFieldCache fieldCache);

+/*

+mama_status printAllMessageFields(mamaFieldCache fieldCache, mamaMsg message);

+*/

+void        printField(mamaFieldCacheField field);

+/*

+mama_status printFieldUsingId(mamaMsgField field, mamaFieldCache fieldCache);

+*/

+/*

+mama_status displayFields(mamaFieldCache fieldCache);

+*/

+

+int main (int argc, const char **argv)

+{

+    mamaTimer mamatimer;

+             mamaTimer shutdownTimer = NULL;

+

+    gSymbolList = (const char**)calloc (MAX_SUBSCRIPTIONS, sizeof (char*));

+    gFieldList  = (const char**)calloc (MAX_FIELDS,        sizeof (char*));

+

+    gSubscriptionList = (mamaSubscription*)calloc (MAX_SUBSCRIPTIONS,

+                                                   sizeof (mamaSubscription));

+

+    parseCommandLine (argc, argv);

+

+    if (gNumSymbols == 0 && !gPrintVersionAndExit)

+    {

+        readSymbolsFromFile ();

+    }

+

+    initializeMama ();

+  

+    buildDataDictionary ();

+    dumpDataDictionary ();

+    loadSymbolMap ();

+

+    /* Create all of the field caches, note that there is 1 per symbol. */

+    createFieldCaches();

+

+    subscribeToSymbols ();

+

+    printf ("Type CTRL-C to exit.\n");

+

+    if (gMsgCount)

+    {

+        printf ("Timestamp           ,  Interval ,   Total\n");

+        mamaTimer_create (&mamatimer,

+                            gMamaDefaultQueue,

+                            rateReporterCallback,

+                            gInterval,

+                            NULL);

+    }

+

+    /* Create the shutdown timer. */

+    if(gShutdownTime > 0)

+    {

+        mamaTimer_create(&shutdownTimer, gMamaDefaultQueue, shutdownTimerCallback, gShutdownTime, NULL);

+    }

+

+    /* Start dispatching on the default event queue, this will block until Ctrl+C is pressed or the shutdown

+             * timer fires.

+             */

+    mama_start (gMamaBridge);

+

+    /* Destroy the shutdown timer if it was created. */

+    if(shutdownTimer != NULL)

+    {

+        mamaTimer_destroy(shutdownTimer);

+    }

+

+    /* Destroy all of the field caches. */

+    destroyFieldCaches();

+

+    mamashutdown ();

+

+    if (gMsgCount)

+    {

+        mamaTimer_destroy (mamatimer);

+    }

+

+    return 0;

+}

+

+/*

+* Create subscriptions for all specified symbols.

+*/

+static void subscribeToSymbols (void)

+{

+    int              howMany = 0;

+    mama_status      status  = MAMA_STATUS_OK;

+    size_t           i;

+    mamaMsgCallbacks callbacks;

+    memset(&callbacks, 0, sizeof(callbacks));

+    callbacks.onCreate  = subscriptionOnCreate;

+    callbacks.onError   = subscriptionOnError;

+    callbacks.onMsg     = subscriptionOnMsg;

+    callbacks.onQuality = subscriptionOnQuality;   

+    callbacks.onGap     = NULL;

+    callbacks.onRecapRequest = NULL;

+    /*

+    * If use of multiple threads/queue was specified create a new mamaQueue

+    * and mamaDispatcher for each one

+    */

+    if ((gThreads > 0) && (gHasCreatedThreads == 0))

+    {

+        gQueues      = (mamaQueue*)calloc

+                            (gThreads, sizeof (mamaQueue));

+        gDispatchers = (mamaDispatcher*)calloc

+                            (gThreads, sizeof (mamaDispatcher));

+

+        for (i = 0; i < gThreads; i++)

+        {

+            if (MAMA_STATUS_OK != (status = mamaQueue_create (&gQueues[i],

+                            gMamaBridge)))

+            {

+                fprintf (stderr, "Error creating queue %s\n",

+                         mamaStatus_stringForStatus( status ) );

+                exit(1);

+            }

+

+            /*Set up queue monitors if specified.*/

+            setQueueMonitors (gQueues[i], i);

+           

+            status = mamaDispatcher_create (&gDispatchers[i] , gQueues[i]);

+

+            if (status != MAMA_STATUS_OK)

+            {

+                fprintf (stderr, "Error creating dispatcher %s\n",

+                         mamaStatus_stringForStatus( status ) );

+                exit(1);

+            }

+        }

+        gHasCreatedThreads = 1;

+    }

+

+    for (i = 0; i < gNumSymbols; i++)

+    {

+        /*If there is more than one queue round robin accross them*/

+        mamaQueue queue = gQueues ==

+                NULL ? gMamaDefaultQueue : gQueues[i % gThreads];

+

+        {

+       

+            mamaSubscription_allocate (&gSubscriptionList[howMany]);

+   

+            mamaSubscription_setTimeout (gSubscriptionList[howMany],

+                                        gTimeout);

+   

+            if (gSnapshot)

+            {

+                /* Create a snapshot subscription */

+                mamaSubscription_setServiceLevel (gSubscriptionList[howMany],

+                                                MAMA_SERVICE_LEVEL_SNAPSHOT,

+                                                0);

+            }

+            else if (gGroupSubscription)

+            {

+                /* Create a group subscription */

+                mamaSubscription_setSubscriptionType

+                                                    (gSubscriptionList[howMany],

+                                                    MAMA_SUBSC_TYPE_GROUP);

+                mamaSubscription_setRequiresInitial (gSubscriptionList[howMany],

+                                                    gRequireInitial);

+            }

+            else

+            {

+                /* Create a regular market data subscription.  */

+                mamaSubscription_setRequiresInitial (gSubscriptionList[howMany],

+                                                    gRequireInitial);

+            }

+   

+            /*

+                Logging at the individual subscription level can be controlled

+                independantly from the global logging level.

+            */

+            mamaSubscription_setDebugLevel (gSubscriptionList[howMany],

+                                            gSubscLogLevel);

+

+            /* Create a verification timer for this subscription and queue. */

+            createVerificationTimer(queue, gSymbolList[i], i);

+   

+            /*

+            The subscription is not created immediately here. Rather an action

+            to create the subscription is placed on the throttle queue.

+            Creation of subscriptions starts once mama_start() is called

+            */

+            status = mamaSubscription_create (gSubscriptionList[howMany],

+                                            queue,

+                                            &callbacks,

+                                            gSubscriptionSource,

+                                            gSymbolList[i],

+                                            (void*)&gFieldCacheIndexes[i]);

+       

+        }

+

+        if (status != MAMA_STATUS_OK)

+        {

+            fprintf (stdout,

+                     "Error creating subscription for %s. STATUS: %s\n",

+                     gSymbolList[i], mamaStatus_stringForStatus(status));

+            /*

+            fprintf (stderr,

+                     "Error creating subscription for %s. STATUS: %s\n",

+                     gSymbolList[i], mamaStatus_stringForStatus(status));

+            */

+            continue;

+        }

+

+        if (++howMany % 1000 == 0)

+        {

+            printf ("Subscribed to %d subjects.\n", howMany);

+        }

+    }

+}

+

+/*

+* Write the contents of the data dictionary to screen.

+*/

+static void dumpDataDictionary (void)

+{

+    mama_fid_t i = 0;

+

+    /*

+        Write the data dictionary to the file system.

+        A data dictionary can be recreated from this file at a later stage.

+    */

+    if (gDictToFile)

+    {

+        printf ("Writing dict to %s\n", gDictFile);

+        mamaDictionary_writeToFile (gDictionary, gDictFile);

+    }

+

+    if (gDumpDataDict)

+    {

+        size_t size = 0;

+       

+        mamaDictionary_getSize (gDictionary, &size);

+

+        printf ("Number of fields in dictionary: %d\n", (unsigned int)size );

+

+        for (i = 0; i < size; i++)

+        {

+            mamaFieldDescriptor field = NULL;

+            mamaDictionary_getFieldDescriptorByIndex (gDictionary,

+                                                      &field,

+                                                      i);

+            if (field)

+            {

+                const char* typeName = "unknown";

+                char tmp[100];

+

+                switch (mamaFieldDescriptor_getType (field))

+                {

+                    case MAMA_FIELD_TYPE_STRING:

+                        typeName = "string";

+                        break;

+                    case MAMA_FIELD_TYPE_BOOL:

+                        typeName = "boolean";

+                        break;

+                    case MAMA_FIELD_TYPE_CHAR:

+                    case MAMA_FIELD_TYPE_I8:

+                        typeName = "char";

+                        break;

+                    case MAMA_FIELD_TYPE_U8:

+                    case MAMA_FIELD_TYPE_I16:

+                    case MAMA_FIELD_TYPE_U16:

+                    case MAMA_FIELD_TYPE_I32:

+                    case MAMA_FIELD_TYPE_U32:

+                    case MAMA_FIELD_TYPE_I64:

+                    case MAMA_FIELD_TYPE_U64:

+                        typeName = "integer";

+                        break;

+                    case MAMA_FIELD_TYPE_F64:

+                        typeName = "double";

+                        break;

+                    case MAMA_FIELD_TYPE_PRICE:

+                        typeName = "price";

+                        break;

+                    default:

+                        snprintf (tmp, 100, "unknown(%d)",

+                                  mamaFieldDescriptor_getType (field));

+                        typeName = tmp;

+                        break;

+                }

+                printf ("  %3d : %-7s : %s\n",

+                        mamaFieldDescriptor_getFid(field), typeName,

+                        mamaFieldDescriptor_getName(field));

+                fflush(stdout);

+            }

+        }

+    }

+}

+

+void MAMACALLTYPE

+timeoutCb (mamaDictionary dict, void *closure)

+{

+    printf ("Timed out waiting for dictionary\n" );

+    mama_stop(gMamaBridge);

+}

+

+void MAMACALLTYPE

+errorCb (mamaDictionary dict, const char *errMsg, void *closure)

+{

+    fprintf (stderr, "Error getting dictionary: %s\n", errMsg );

+    mama_stop(gMamaBridge);

+}

+

+void MAMACALLTYPE

+completeCb (mamaDictionary dict, void *closure)

+{

+    gDictionaryComplete = 1;

+    /*

+       Stop processing events until all subscriptions have been created.

+    */

+    mama_stop (gMamaBridge);

+}

+

+static void buildDataDictionary (void)

+{

+    mamaDictionaryCallbackSet dictionaryCallback;

+    mama_status result  =   MAMA_STATUS_OK;

+    if (gBuildDataDict)

+    {

+        memset(&dictionaryCallback, 0, sizeof(dictionaryCallback));

+        dictionaryCallback.onComplete = completeCb;

+        dictionaryCallback.onTimeout  = timeoutCb;

+        dictionaryCallback.onError    = errorCb;

+

+        /*

+           The dictionary is created asychronously. The dictionary has been

+           successfully retreived once the onComplete callback has been

+           invoked.

+        */

+        result = mama_createDictionary (&gDictionary,

+                                        gMamaDefaultQueue,/*Use the default event queue*/

+                                        dictionaryCallback,

+                                        gDictSource,

+                                        10.0,

+                                        3,

+                                        NULL);/*Don't specify a closure*/

+

+        if (result != MAMA_STATUS_OK)

+        {

+            fprintf (stderr, "Exception creating "

+                            "dictionary: MamaStatus: %s\n",

+                            mamaStatus_stringForStatus (result));

+            exit (1);

+        }

+

+        /*

+            Start dispatching on the default event queue. Dispatching on the

+            queue is unblocked once one of the dictionary callbacks is invoked.

+        */

+        mama_start (gMamaBridge);

+

+        /*

+            True only if onComplete resulted in the unblocking of the queue

+            dispatching

+        */

+        if (!gDictionaryComplete)

+        {

+            fprintf (stderr, "Could not create dictionary.\n" );

+            exit(1);

+        }

+       

+

+    }

+    else if (gDictFromFile)

+    {

+        mamaDictionary_create (&gDictionary);

+        mamaDictionary_populateFromFile(

+                gDictionary,

+                gDictFile);

+    }

+}

+static void mamashutdown (void)

+{

+    int i;

+   

+    /* Stop all the queues. */

+    if (gQueues != NULL)

+    {

+        fprintf(stderr, "mamashutdown: destroying dispatch queues\n");

+        for (i = 0; i < gThreads; i++)

+        {

+            mamaDispatcher_destroy (gDispatchers[i]);

+        }

+        free (gDispatchers);

+    }

+   

+    fprintf(stderr, "mamashutdown: free-ing symbol and field lists\n");

+    for (i = 0; i < gNumSymbols; i++)

+    {

+        free ((char *)gSymbolList[i]);

+    }

+    free ((void*)gSymbolList);

+   

+    for (i = 0; i < gNumFields; i++)

+    {

+        free ((char *)gFieldList[i]);

+    }

+    free ((void *)gFieldList);

+

+

+    fprintf(stderr, "mamashutdown: destroying subscriptions\n");

+

+    {

+   

+        for (i = 0; i < gNumSymbols; i++)

+        {

+            if (gSubscriptionList[i])

+            {

+                mamaSubscription_destroy (gSubscriptionList[i]);

+                mamaSubscription_deallocate (gSubscriptionList[i]);

+            }

+        }

+        free (gSubscriptionList);

+    }

+   

+    /* Destroy the source. */

+    if(NULL != gSubscriptionSource)

+    {

+        mamaSource_destroy(gSubscriptionSource);

+    }

+   

+    if (gQueues != NULL)

+    {

+        fprintf(stderr, "mamashutdown: destroying queues\n");

+        for (i = 0; i < gThreads; i++)

+        {

+            mamaQueue_destroyWait (gQueues[i]);

+        }

+        free (gQueues);

+    }

+

+    /* Destroy the dictionary. */

+    if (gDictionary != NULL)

+    {

+        fprintf(stderr, "mamashutdown: destroying dictionary\n");

+        mamaDictionary_destroy(gDictionary);

+    }

+   

+    /* Destroy the dictionary source. */

+    if(NULL != gDictSource)

+    {

+        mamaSource_destroy(gDictSource);

+    }

+   

+    if (gTransport != NULL)

+    {

+        fprintf(stderr, "mamashutdown: destroying transport\n");

+        mamaTransport_destroy (gTransport);

+    }

+   

+    mama_close ();

+}

+

+static void MAMACALLTYPE

+transportCb (mamaTransport      tport,

+             mamaTransportEvent ev,

+             short              cause,

+             const void*        platformInfo,

+             void*              closure)

+{

+    printf ("Transport callback: %s\n", mamaTransportEvent_toString (ev));

+}

+

+/*Steps required for initializing the API*/

+void initializeMama (void)

+{

+    mama_status               status  =   MAMA_STATUS_OK;

+    /*

+        mama_setApplicationName should be called before mama_open().

+    */

+    if (gAppName)

+    {

+        mama_setApplicationName (gAppName);

+    }

+

+    status = mama_loadBridge (&gMamaBridge, gMiddleware);

+

+    if (gPrintVersionAndExit)

+    {

+        if (gMamaBridge != NULL)

+        {

+            printf ("%s\n",mama_getVersion(gMamaBridge));

+        }

+        exit (0);

+    }

+

+    if (MAMA_STATUS_OK!=status)

+    {

+        fprintf (stderr,"Could not open MAMA %s bridge.\n",

+                                         gMiddleware);

+        exit (1);

+    }

+

+    /*

+        mama_open() should be the first MAMA API call made in an

+        application, with the exception of mama_loadBridge,

+        mama_setApplicationName(), mama_setApplicationClassName()

+        and mama_setProperty().

+        It is reference counted. mama_close() must be called a

+        corresponding number of times.

+    */

+    if (MAMA_STATUS_OK!=(status=mama_open ()))

+    {

+        fprintf (stderr,

+                 "Failed to initialize MAMA STATUS: %d (%s)\n", status,

+                 mamaStatus_stringForStatus (status));

+        exit(1);

+    }

+

+    /*Get the default event queue*/

+    mama_getDefaultEventQueue (gMamaBridge, &gMamaDefaultQueue);

+

+    /*Check if we are monitoring queue activity*/

+    setQueueMonitors (gMamaDefaultQueue, -1);

+

+    /*Using a single transport for all subscriptions*/

+    status = mamaTransport_allocate (&gTransport);

+

+    if (status != MAMA_STATUS_OK)

+    {

+        fprintf (stderr,

+                 "Failed to allocate transport STATUS: %d %s\n", status,

+                 mamaStatus_stringForStatus (status));

+        exit(1);

+    }

+

+    /*Register interest in transport related events*/

+    status = mamaTransport_setTransportCallback(gTransport, transportCb, NULL);

+

+    /*The default throttle rate is 500 msg/sec*/

+    if (gThrottle != -1)

+    {

+        if (MAMA_STATUS_OK!=(status=mamaTransport_setOutboundThrottle (gTransport,

+                                           MAMA_THROTTLE_DEFAULT,

+                                           gThrottle)))

+        {

+            fprintf (stderr, "Could not set default throttle"

+                      "rate [%s]\n", mamaStatus_stringForStatus (status));

+        }

+    }

+

+    /*The default recap throttle rate is 250 msg/sec*/

+    if (gRecapThrottle != -1)

+    {

+        if (MAMA_STATUS_OK!=(status=mamaTransport_setOutboundThrottle (gTransport,

+                                           MAMA_THROTTLE_RECAP,

+                                           gRecapThrottle)))

+        {

+            fprintf (stderr, "Could not set recap throttle"

+                      "rate [%s]\n", mamaStatus_stringForStatus (status));

+        }

+    }

+   

+    /* Create the transport after any properties have been set. */

+    if (MAMA_STATUS_OK!=

+       (status=mamaTransport_create (gTransport, gTport, gMamaBridge)))

+    {

+        fprintf (stderr,

+                 "Failed to create transport STATUS: %d %s\n", status,

+                 mamaStatus_stringForStatus (status));

+        exit(1);

+    }

+

+    if (!gQualityForAll)

+    {

+        mamaTransport_setInvokeQualityForAllSubscs (gTransport, 0);

+    }

+   

+    /*

+        The mamaSource replaces the individual specifying of the

+        symbolNameSpace and the transport. The mamaSource acts as a unique

+        identifier for a source of data. Multiple subscriptions will typically

+        be created using a single mamaSource instance.

+    */

+   

+    /*The mamaSource used for all subscription creation*/

+    if (MAMA_STATUS_OK!=(status=mamaSource_create (&gSubscriptionSource)))

+    {

+        fprintf (stderr,

+                 "Failed to create subscription mamaSource STATUS: %d %s\n",

+                 status, mamaStatus_stringForStatus (status));

+        exit(1);

+    }

+   

+    mamaSource_setId (gSubscriptionSource, "Subscription_Source");

+    mamaSource_setTransport (gSubscriptionSource, gTransport);

+    mamaSource_setSymbolNamespace (gSubscriptionSource, gSymbolNamespace);

+   

+    /*Specify a separate transport on which to retreive the dictioanry*/

+    if (gDictTport != NULL)

+    {

+        fprintf (stderr,

+                 "Creating data dictionary transport using name: %s\n",

+                 gDictTport);

+        if (strlen(gDictTport)==0) gDictTport = NULL;

+       

+        status = mamaTransport_allocate (&gDictTransport);

+        status = mamaTransport_create (gDictTransport, gDictTport, gMamaBridge);

+        if (status != MAMA_STATUS_OK)

+        {

+            fprintf (stderr,

+                     "Failed to create data dictionary transport STATUS: %d %s\n",

+                     status, mamaStatus_stringForStatus (status));

+            exit(1);

+        }

+    }

+    else

+    {

+        gDictTransport = gTransport;

+    }

+

+    /*The mamaSource used for creating the dictionary*/

+    if (MAMA_STATUS_OK!=(status=mamaSource_create (&gDictSource)))

+    {

+        fprintf (stderr,

+                 "Failed to create dictionary mamaSource STATUS: %d %s\n",

+                 status, mamaStatus_stringForStatus (status));

+        exit(1);

+    }      

+

+    mamaSource_setId (gDictSource, "Dictionary_Source");

+    mamaSource_setTransport (gDictSource, gDictTransport);

+    mamaSource_setSymbolNamespace (gDictSource, gDictSymbolNamespace);

+}

+

+static void readSymbolsFromFile (void)

+{

+    /* get subjects from file or interactively */

+    FILE* fp = NULL;

+    char charbuf[1024];

+

+    if (gFilename)

+    {

+        if ((fp = fopen (gFilename, "r")) == (FILE *)NULL)

+        {

+            perror (gFilename);

+            exit (1);

+        }

+    }

+    else

+    {

+        fp = stdin;

+    }

+    if (isatty(fileno (fp)))

+    {

+        printf ("Enter one symbol per line and terminate with a .\n");

+        printf ("Symbol> ");

+    }

+    while (fgets (charbuf, 1023, fp))

+    {

+        char *c = charbuf;

+

+        /* Input terminate case */

+        if (*c == '.')

+            break;

+

+        /* replace newlines with NULLs */

+        while ((*c != '\0') && (*c != '\n'))

+            c++;

+        *c = '\0';

+       

+        gSymbolList[gNumSymbols++] = strdup (charbuf);

+        if (isatty(fileno (fp)))

+            printf ("Symbol> ");

+    }

+}

+

+static void loadSymbolMap (void)

+{

+    if (gMapFilename)

+    {

+        mama_status status = mamaSymbolMapFile_create (&gSymbolMapFromFile);

+        if (status == MAMA_STATUS_OK)

+        {

+            status = mamaSymbolMapFile_load (gSymbolMapFromFile,

+                                             gMapFilename);

+        }

+

+        if (status != MAMA_STATUS_OK)

+        {

+            fprintf (stderr,

+                     "Failed to initialize symbol map file: %s\n",

+                     gMapFilename);

+            exit (1);

+        }

+

+        mamaTransport_setSymbolMapFunc (

+                            gTransport,

+                            (mamaSymbolMapFunc)mamaSymbolMapFile_map,

+                            gSymbolMapFromFile);

+    }

+}

+

+static void parseCommandLine (int argc, const char** argv)

+{

+    int i = 1;

+    

+    for (i = 1; i < argc; )

+    {

+        if ((strcmp (argv[i], "-S") == 0) ||

+            (strcmp (argv[i], "-source") == 0)||

+            (strcmp (argv[i], "-SN") == 0)||

+            (strcmp (argv[i], "-symbolnamespace") == 0))

+        {

+            gSymbolNamespace = argv[i + 1];

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-d") == 0)

+        {

+            gDictSymbolNamespace = argv[i + 1];

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-D") == 0)

+        {

+            gDumpDataDict = 1;

+            i++;

+        }

+        else if (strcmp (argv[i], "-DF") == 0)

+        {

+            gDictToFile = 1;

+            gDictFile = argv[i+1];

+            i+=2;

+        }

+        else if (strcmp (argv[i], "-B") == 0)

+        {

+            gBuildDataDict = 0;

+            i++;

+        }

+        else if (strcmp (argv[i], "-I") == 0)

+        {

+            gRequireInitial = 0;

+            i++;

+        }

+        else if (strcmp (argv[i], "-g") == 0)

+        {

+            gGroupSubscription = 1;

+            i++;

+        }

+        else if (strcmp (argv[i], "-s") == 0)

+        {

+            if (argv[i + 1] != NULL)

+            {

+                gSymbolList[gNumSymbols++]=strdup (argv[i + 1]);

+                i += 2;

+            }

+            else

+            {

+                gSymbolList[gNumSymbols++]="";

+                i += 2;

+            }

+        }

+        else if (strcmp (argv[i], "-f") == 0)

+        {

+            gFilename = argv[i + 1];

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-1") == 0)

+        {

+            gSnapshot = 1;

+            i++;

+        }

+        else if (strcmp ("-m", argv[i]) == 0)

+        {

+            gMiddleware = argv[i+1];

+            i += 2;              

+        }

+        else if (strcmp (argv[i], "-r") == 0)

+        {

+            gThrottle = strtol (argv[i+1], NULL, 10);

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-rr") == 0)

+        {

+            gRecapThrottle = strtol (argv[i+1], NULL, 10);

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-t") == 0)

+        {

+            gTimeout = strtod (argv[i+1], NULL);

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-q") == 0)

+        {

+            gQuietness++;

+            i++;

+        }

+        else if (strcmp (argv[i], "-E") == 0)

+        {

+            gExtractData=0;

+            i++;

+        }

+        else if (strcmp (argv[i], "-c") == 0)

+        {

+            gMsgCount=1;

+            gInterval = strtol (argv[i+1], NULL,10);

+            if (gInterval < 1)

+            {

+                gInterval=2;

+            }

+            i+=2;

+        }

+        else if (strcmp (argv[i], "-mp") == 0)

+        {

+            gMapFilename = argv[i + 1];

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-threads") == 0)

+        {

+            gThreads = atoi (argv[i + 1]);

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-A") == 0)

+        {

+            gQualityForAll = 0;

+            i++;

+        }

+        else if (strcmp (argv[i], "-tport") == 0)

+        {

+            gTport = argv[i+1];

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-dict_tport") == 0)

+        {

+            gDictTport = argv[i+1];

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-v") == 0)

+        {

+            if (mama_getLogLevel () == MAMA_LOG_LEVEL_WARN)

+            {

+                mama_enableLogging (stderr, MAMA_LOG_LEVEL_NORMAL);

+            }

+            else if (mama_getLogLevel () == MAMA_LOG_LEVEL_NORMAL)

+            {

+                mama_enableLogging (stderr, MAMA_LOG_LEVEL_FINE);

+            }

+            else if (mama_getLogLevel () == MAMA_LOG_LEVEL_FINE)

+            {

+                mama_enableLogging (stderr, MAMA_LOG_LEVEL_FINER);

+            }

+            else

+            {

+                mama_enableLogging (stderr, MAMA_LOG_LEVEL_FINEST);

+            }

+            i++;

+        }

+        else if ( strcmp( argv[i], "-log_file" ) == 0 )

+        {

+            gLogFile = fopen( argv[i+1],"w+" );

+            if( gLogFile == NULL)

+            {

+                fprintf (stderr, "Failed open log file %s\n",argv[i+1] );

+                exit(1);

+            }

+            else

+            {

+                mama_enableLogging (gLogFile, mama_getLogLevel ());

+            }

+            i += 2;

+        }

+        else if ( strcmp( argv[i], "-app" ) == 0 )

+        {

+            gAppName = argv[i+1];

+            i += 2;

+        }

+        else if ( strcmp( argv[i], "-ni" ) == 0 )

+        {

+            gNewIterators = 1;

+            i++;

+        }

+        else if (strcmp( argv[i], "-hw" ) == 0)

+        {

+            gHighWaterMark = atoi (argv [i+1]);   

+            i += 2;

+        }

+        else if (strcmp( argv[i], "-lw" ) == 0)

+        {

+            gLowWaterMark = atoi (argv [i+1]);   

+            i += 2;

+        }

+        else if ( strcmp( argv[i], "-V" ) == 0 )

+        {

+            if (gSubscLogLevel == MAMA_LOG_LEVEL_NORMAL)

+            {

+                gSubscLogLevel = MAMA_LOG_LEVEL_FINE;

+            }

+            else if (gSubscLogLevel == MAMA_LOG_LEVEL_FINE)

+            {

+                gSubscLogLevel = MAMA_LOG_LEVEL_FINER;

+            }

+            else

+            {

+                gSubscLogLevel = MAMA_LOG_LEVEL_FINEST;

+            }

+

+            i++;

+        }

+        else if (strcmp (argv[i], "-version") == 0)

+        {

+            gPrintVersionAndExit = 1;

+            i+=1;

+        }

+        else if ((strcmp (argv[i], "-?") == 0)||

+                 ((strcmp (argv[i], "--help") == 0)))

+        {

+            usage (0);

+        }

+        else if (strcmp (argv[i], "-use_dict_file") == 0)

+        {

+            gDictFromFile = 1;

+            gBuildDataDict =0;

+            gDictFile = strdup (argv[i+1]);

+            i+=2;

+        }

+       

+        else if (strcmp ("-shutdown", argv[i]) == 0)

+        {

+            gShutdownTime = atoi (argv[i + 1]);

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-verifyCache") == 0)

+        {

+            gVerifyCache = 1;

+            i++;

+        }

+        else if (strcmp (argv[i], "-verifyInterval") ==  0)

+        {

+            gVerifyInterval = strtod (argv[i+1], NULL);

+            i += 2;

+        }

+        else if (strcmp (argv[i], "-no_display") == 0)

+        {

+            gNoDisplay = 1;

+            i++;

+        }

+        else if (strcmp (argv[i],"-printCache") == 0)

+        {

+            gPrintCache = 1;

+            i++;

+        }

+        else

+        {

+            gFieldList[gNumFields++] = strdup (argv[i]);

+            i++;

+        }

+    }

+}

+

+/*

+    This callback function, passed to the mamaSubscription upon creation, is

+    where most of the processing within a MAMA based application will occur.

+    This callback is invoked for each message received by the API.

+*/

+void MAMACALLTYPE

+subscriptionOnMsg  (mamaSubscription subscription,

+                    mamaMsg msg,

+                    void *closure,

+                    void *itemClosure)

+{

+    mamaMsg message;

+    /* The closure is the index of the subscription within the list. */

+

+    mamaFieldCache fieldCache = NULL;

+

+    int subscriptionIndex = 0;

+   

+    if (closure)

+    {

+        subscriptionIndex = *(int*)closure;

+

+        /* Get the field cache for this symbol. */

+        fieldCache = gFieldCaches[subscriptionIndex];

+    }

+   

+    gNumMsg++;

+

+    /*

+        The type and status of a mamaMsg can indicate how the message should

+        be interpretated.

+    */

+    switch (mamaMsgType_typeForMsg (msg))

+    {

+    case MAMA_MSG_TYPE_SNAPSHOT:   

+        {

+            checkSnapshotIntegrity(fieldCache, msg);

+            return;

+        }

+    case MAMA_MSG_TYPE_DELETE:

+    case MAMA_MSG_TYPE_EXPIRE:

+        mamaSubscription_destroy (subscription);

+        mamaSubscription_deallocate (subscription);

+        gSubscriptionList[subscriptionIndex] = 0;

+

+        if (--gNumSubscriptions == 0)

+        {

+            fprintf (stderr,

+                     "Symbol deleted or expired. No more subscriptions\n");

+            exit(1);

+        }

+        return;

+    default:

+        break;

+    }

+

+    switch (mamaMsgStatus_statusForMsg (msg))

+    {

+    case MAMA_MSG_STATUS_BAD_SYMBOL:

+    case MAMA_MSG_STATUS_EXPIRED:

+    case MAMA_MSG_STATUS_TIMEOUT:

+        mamaSubscription_destroy (subscription);

+        mamaSubscription_deallocate (subscription);

+        gSubscriptionList[subscriptionIndex] = 0;

+       

+        if (--gNumSubscriptions == 0)

+        {

+            fprintf (stderr, "Bad or expired symbol.\n" );

+            exit(1);

+        }

+        return;

+    default:

+        break;

+    }

+   

+    /* Apply the message to the field cache. */

+    mamaFieldCache_applyMessage(fieldCache, msg, gDictionary);

+

+    mamaMsg_create(&message);

+    mamaFieldCache_getFullMessage(fieldCache, message);

+

+    if (!gNoDisplay)

+    {

+        if (gNumFields == 0)

+        {

+            displayAllFields(message, subscription, 0);

+        }

+        else

+        {

+            displayFields(message, subscription);

+        }

+

+        if (gPrintCache)

+        {

+            displayHeader(msg, subscription);

+            printAllCacheFields(fieldCache);

+        }

+    }

+

+    mamaMsg_clear(message);

+    mamaFieldCache_getDeltaMessage(fieldCache, message);

+    mamaMsg_destroy(message);

+

+    fflush(stdout);

+}

+

+/*

+    The onQuality callback is invoked when the quality of a subscription

+    changes state. E.g. From OK to STALE and vise versa.

+*/

+void MAMACALLTYPE

+subscriptionOnQuality (mamaSubscription subsc,

+                       mamaQuality      quality,

+                       const char*      symbol,

+                       short            cause,

+                       const void*      platformInfo,

+                       void*            closure)

+{

+    printf ("Quality changed to %s for %s, cause %d, platformInfo: %s\n",

+            mamaQuality_convertToString (quality), symbol, cause,

+            platformInfo ? (char*)platformInfo: "");

+}

+

+

+void displayFields(mamaMsg msg, mamaSubscription subscription )

+{

+    const char* source = NULL;

+    const char* symbol = NULL;

+    int         i      = 0;

+

+    mamaSubscription_getSource (subscription, &source);

+    mamaSubscription_getSymbol (subscription, &symbol);

+

+    if (gQuietness < 2)

+    {

+        const char* issueSymbol = NULL;

+        mamaMsg_getString (msg, NULL, 305, &issueSymbol);

+        printf ("%s.%s.%s Type: %s Status %s \n",

+                       issueSymbol,

+                       source,

+                       symbol,

+                       mamaMsgType_stringForMsg (msg),

+                       mamaMsgStatus_stringForMsg (msg));

+    }

+

+    for (i = 0; i < gNumFields; i++)

+    {

+        mamaFieldDescriptor field = NULL;

+

+        /*

+            Get the field descriptor for the specified field from the data

+            dictionary. This will be used to extract data for that field from

+            the message.

+        */

+        mamaDictionary_getFieldDescriptorByName (

+                    gDictionary,

+                    &field,

+                    gFieldList[i]);

+

+        displaySpecificField (field, msg);

+    }

+

+}

+/*

+void displayFields(mamaFieldCache fieldCache)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaFieldCacheField cacheField = NULL;

+    int fieldIndex = 0;

+    mamaFieldDescriptor descriptor = NULL;

+

+    while((ret == MAMA_STATUS_OK) && (fieldIndex < gNumFields))   

+    {

+        ret = mamaDictionary_getFieldDescriptorByName(gDictionary,

+                                                      &descriptor,

+                                                      gFieldList[fieldIndex]);

+        if(ret == MAMA_STATUS_OK)

+        {

+            ret = mamaFieldCache_find(fieldCache,

+                    mamaFieldDescriptor_getFid(descriptor),

+                    NULL,

+                    &cacheField);

+            if(ret == MAMA_STATUS_OK)

+            {

+                printField(cacheField);

+            }

+        }

+        fieldIndex++;

+    }

+    return ret;

+}

+*/

+

+void displaySpecificField (mamaFieldDescriptor field,

+                           mamaMsg             msg)

+{

+    const char* fieldName   =   NULL;

+    short       fid         =   0;

+    char value[256];

+

+    if (field == NULL) return;

+

+    /*

+        The mamaFieldDescriptor contains meta data describing a fields

+        attributes. The name and the fid for a field can be obtained from the

+        descriptor.

+    */

+    fieldName = mamaFieldDescriptor_getName (field);

+    fid = mamaFieldDescriptor_getFid (field);

+

+    if (fieldName == NULL || strlen (fieldName) == 0)

+    {

+        mamaFieldDescriptor dictEntry;

+        mamaDictionary_getFieldDescriptorByFid (gDictionary, &dictEntry, fid);

+

+        fieldName = mamaFieldDescriptor_getName (dictEntry);

+    }

+

+    if (gQuietness < 3)

+    {

+        /*

+          If performance is an issue do not use getFieldAsString. Rather, use

+          the strongly typed accessors on the message or field objects.

+          For absolute performance use field iteration rather than direct

+          message access.

+        */

+        mama_status status = mamaMsg_getFieldAsString (msg,

+                                                       fieldName,

+                                                       fid,

+                                                       value,

+                                                       256);

+        if (gQuietness < 1)

+        {

+            if (MAMA_STATUS_NOT_FOUND == status)

+            {

+                sprintf (value,"%s","Field Not Found");

+            }

+

+            printf ("%-20s | %3d | %20s | %s\n",

+                    fieldName,

+                    fid,

+                    mamaFieldDescriptor_getTypeName (field),

+                    value);

+        }

+    }

+}

+

+#define printData(value, format)                \

+do                                              \

+{                                               \

+    if (gQuietness==0)                           \

+    {                                           \

+        printf (format, value);                 \

+    }                                           \

+} while (0)                                     \

+

+void displayField (mamaMsgField field, const mamaMsg msg, int indentLevel)

+{

+    mamaFieldType   fieldType       =   0;

+    const char*     fieldName       = NULL;

+    const char*     fieldTypeName   = NULL;

+    uint16_t        fid             = 0;

+    const char*     indentOffset    = NULL;

+    const char*     indentOffsetAll = "%-20s | %4d | %13s | ";

+

+    if (!gExtractData)return;

+

+    /*For formatting of output only*/

+    switch (indentLevel)

+    {

+        case 0:

+            indentOffset = "%2s";

+            break;

+        case 1:

+            indentOffset = "%4s";

+            break;

+        case 2:

+            indentOffset = "%6s";

+            break;

+        case 3:

+            indentOffset = "%8s";

+            break;

+        default:

+            indentOffset = "%10s";

+    }

+

+    if (gQuietness<1)

+    {

+        printData ("",indentOffset);

+        /*

+            Attributes for a field can be obtained directly from the field

+            rather than from the field descriptor describing that field.

+        */

+        mamaMsgField_getName (field, &fieldName);

+        mamaMsgField_getFid  (field, &fid);

+        mamaMsgField_getTypeName (field, &fieldTypeName);

+        printf (indentOffsetAll,

+                fieldName ? fieldName : "",

+                fid,

+                fieldTypeName);

+    }

+

+    /*

+        The most efficient way of extracting data while iterating fields is to

+        obtain the field type and then call the associated strongly typed

+        accessor.

+

+        mamaMsgField_getAsString() will return a stringified version of the

+        data but is considerably less efficient and is not recommended for

+        production use.

+    */

+    mamaMsgField_getType (field, &fieldType);

+

+    switch (fieldType)

+    {

+        case MAMA_FIELD_TYPE_BOOL:

+            {

+                mama_bool_t result;

+                mamaMsgField_getBool (field, &result);

+                printData (result, "%d\n");

+                break;

+            }

+        case MAMA_FIELD_TYPE_CHAR:

+            {

+                char result;

+                mamaMsgField_getChar (field, &result);

+                printData (result, "%c\n");

+                break;

+            }

+        case MAMA_FIELD_TYPE_I8:

+            {

+                int8_t result;

+                mamaMsgField_getI8 (field, &result);

+                printData (result, "%d\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_U8:

+            {

+                uint8_t result;

+                mamaMsgField_getU8 (field, &result);

+                printData (result, "%u\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_I16:

+            {

+                int16_t result;

+                mamaMsgField_getI16 (field, &result);

+                printData (result, "%d\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_U16:

+            {

+                uint16_t result;

+                mamaMsgField_getU16 (field, &result);

+                printData (result, "%u\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_I32:

+            {

+                int32_t result;

+                mamaMsgField_getI32 (field, &result);

+                printData (result, "%d\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_U32:

+            {

+                uint32_t result;

+                mamaMsgField_getU32 (field, &result);

+                printData (result, "%u\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_I64:

+            {

+                int64_t result;

+                mamaMsgField_getI64 (field, &result);

+                printData (result, "%"PRId64"\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_U64:

+            {

+                uint64_t result;

+                mamaMsgField_getU64 (field, &result);

+                printData (result, "%"PRId64"\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_F32:

+            {

+               mama_f32_t result;

+               mamaMsgField_getF32 (field, &result);

+               printData (result, "%f\n");

+               break;

+            }

+         case MAMA_FIELD_TYPE_F64:

+            {

+                mama_f64_t result;

+                mamaMsgField_getF64 (field, &result);

+                printData (result, "%f\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_TIME:

+            {

+                mamaDateTime result = NULL;

+                char         dateTimeString[56];

+                mamaDateTime_create (&result);

+                mamaMsgField_getDateTime (field, result);

+                mamaDateTime_getAsString (result,dateTimeString, 56);

+                printData (dateTimeString, "%s\n");

+                mamaDateTime_destroy (result);

+                break;

+            }

+         case MAMA_FIELD_TYPE_PRICE:

+            {

+                mamaPrice result;

+                char      priceString[56];

+                mamaPrice_create (&result);

+                mamaMsgField_getPrice (field, result);

+                mamaPrice_getAsString (result, priceString, 56);

+                printData (priceString, "%s\n");

+                mamaPrice_destroy (result);

+                break;

+            }

+         case MAMA_FIELD_TYPE_STRING:

+            {

+                const char* result = NULL;

+                mamaMsgField_getString (field, &result);

+                printData (result, "%s\n");

+                break;

+            }

+         case MAMA_FIELD_TYPE_VECTOR_STRING:

+            {

+                const char** result = NULL;

+                mama_size_t size = 0;

+                mama_size_t i;

+                mamaMsgField_getVectorString (

+                    field,

+                    &result,

+                    &size);

+                printData("","%s\n");

+                for (i=0;i<size;i++)

+                {

+                    printData("",indentOffset);

+                    printData(result[i], "  %s\n");

+                }

+                break;

+            }

+         case MAMA_FIELD_TYPE_VECTOR_I32:

+            {

+              const mama_i32_t* result = NULL;

+              mama_size_t size = 0;

+              mama_size_t i =0;

+              mamaMsgField_getVectorI32 (field,&result,&size);

+              printData("","%s\n");

+              for (i=0;i<size;i++)

+              {

+                 printData("", indentOffset);

+                 printData(result[i], " %d\n");

+              }

+                break;

+            }

+

+         case MAMA_FIELD_TYPE_VECTOR_F64:

+            {

+              const mama_f64_t* result = NULL;

+              mama_size_t size = 0;

+              mama_size_t i =0;

+              mamaMsgField_getVectorF64 (field,&result,&size);

+              printData("","%s\n");

+              for (i=0;i<size;i++)

+              {

+                 printData("", indentOffset);

+                 printData(result[i], " %f\n");

+              }

+                break;

+            }

+         case MAMA_FIELD_TYPE_MSG:

+            {

+                mamaMsg result;

+                mamaMsgField_getMsg (field, &result);

+                printData ("", "%s\n");

+                displayAllFields (result, NULL, indentLevel+1);

+                break;

+            }

+         case MAMA_FIELD_TYPE_VECTOR_MSG:

+            {

+                /*

+                    Vectors of messages are only supported using WomabtMsg as

+                    the wire encoding data format. The example here

+                    recursively prints all data in all messages.

+                */

+                const mamaMsg*  result;

+                mama_size_t     resultLen;

+                int             i;

+                mamaMsgField_getVectorMsg (field, &result, &resultLen);

+                printData ("", "%s\n");

+                printData ("",indentOffset);

+                printData ("{", "%s\n");

+                for (i=0;i<resultLen;i++)

+                {

+                    displayAllFields (result[i], NULL, indentLevel+1);

+                }

+                printData ("",indentOffset);

+                printData ("}", "%s\n");

+                break;

+            }

+        default:

+            {

+                printData ("Unknown", "%s\n");

+            }

+            break;

+    }/*End switch*/

+}

+

+void MAMACALLTYPE

+displayCb (const mamaMsg       msg,

+                const mamaMsgField  field,

+                void*               closure)

+{

+    displayField (field, msg, (int)closure);

+}

+

+void displayAllFields (mamaMsg msg, mamaSubscription subscription, int

+        indentLevel)

+{

+    mamaMsgField    field       =   NULL;

+    mama_status     status      =   MAMA_STATUS_OK;

+

+    if (gQuietness < 2 && subscription)

+    {

+        const char* source = NULL;

+        const char* symbol = NULL;

+        const char* issueSymbol = NULL;

+

+        mamaSubscription_getSource (subscription, &source);

+        mamaSubscription_getSymbol (subscription, &symbol);

+        mamaMsg_getString (msg, NULL, 305, &issueSymbol);

+        printf ("%s.%s.%s Type: %s Status %s \n",

+                issueSymbol == NULL ? "" : issueSymbol,

+                source      == NULL ? "" : source,

+                symbol      == NULL ? "" : symbol,

+                mamaMsgType_stringForMsg (msg),

+                mamaMsgStatus_stringForMsg (msg));

+    }

+

+    /*

+        Iterating over all the fields in a message is more efficient than

+        accessing data directly on the message object itself. When accessing

+        the message directly the message must first find the field before

+        returning the data. For messages which do not contain the requested

+        field this requires traversal of the whole message before returning.

+        Using the iteration approach requires that each field within the

+        message is only visited once.

+    */

+    if (gNewIterators == 0)

+    {

+        mamaMsg_iterateFields (msg, displayCb, gDictionary, (void*)indentLevel);

+    }

+    else

+    {

+             if (gNewIterators != 0)

+             {

+                             mamaMsgIterator iterator = NULL;

+             /*An iterator can be reused for efficiency - however, it cannot

+                             be shared across all queues*/

+             mamaMsgIterator_create(&iterator, gDictionary);

+

+             if (MAMA_STATUS_OK!=(status=mamaMsgIterator_associate(iterator, msg)))

+             {

+                             fprintf (stderr, "Could not associate iterator "

+                                             "with message. [%s]\n", mamaStatus_stringForStatus (status));

+             }

+             else

+             {

+                             while ((field = mamaMsgIterator_next(iterator)) != NULL)

+                             {

+                                             displayField (field, msg, 0);

+                             }

+             }

+

+                             mamaMsgIterator_destroy(iterator);

+             }

+    }

+}

+

+/*

+    Creation of subscriptions is throttled by the API. The onCreate callback

+    is invoked whenther the subscription request is sent from the throttle

+    queue.

+*/

+

+void MAMACALLTYPE

+subscriptionOnCreate (mamaSubscription subscription, void* closure)

+{  

+    const char* source = NULL;

+    const char* symbol = NULL;

+    mamaQueue queue;

+

+    gNumSubscriptions++;

+    mamaSubscription_getSource (subscription, &source);

+    mamaSubscription_getSymbol (subscription, &symbol);

+

+    mamaSubscription_getQueue(subscription, &queue);

+

+    if (gQuietness < 3)

+    {

+        fprintf(stdout,

+            "Created subscription: source=[%s], symbol=[%s]\n",

+            source, symbol);

+    }

+}

+

+static void MAMACALLTYPE

+subscriptionOnError (mamaSubscription subscription,

+                     mama_status      status,

+                     void*            platformError,

+                     const char*      subject,

+                     void*            closure)

+{

+    fprintf (stdout,

+             "An error occurred creating subscription for %s: %s\n",

+             subject ? subject : "(null)",

+             mamaStatus_stringForStatus (status));

+}

+

+static void MAMACALLTYPE

+rateReporterCallback (mamaTimer  timer, void*   closure)

+{

+    int           msgInterval = gNumMsg - gNumMsgLast;

+    char          timeStr[20];

+    mamaDateTime  now;

+

+    mamaDateTime_create (&now);

+    mamaDateTime_setToNow (now);

+    mamaDateTime_getAsFormattedString (now, timeStr, 20, "%F %T");

+    mamaDateTime_destroy (now);

+    printf ("%s, %-10d, %-12ld\n", timeStr, msgInterval, gNumMsg);

+    gNumMsgLast = gNumMsg;

+}

+

+void usage (int exitStatus)

+{

+    int i = 0;

+    while (gUsageString[i]!=NULL)

+    {

+        printf ("%s\n", gUsageString[i++]);

+    }

+    exit (exitStatus);

+}

+

+static void MAMACALLTYPE

+highWaterMarkCallback (mamaQueue     queue,

+                       size_t        size,

+                       void*         closure)

+{

+    mama_status status      = MAMA_STATUS_OK;

+    const char* queueName   = NULL;

+

+    if (queue)

+    {

+        if (MAMA_STATUS_OK!=(status=mamaQueue_getQueueName (queue, &queueName)))

+        {

+            fprintf (stderr, "Could not get queue name [%s]",

+                     mamaStatus_stringForStatus (status));

+        }

+    }

+    else /*Default queue*/

+    {

+        queueName = "DEFAULT_QUEUE";

+    }

+

+    printf ("%s high water mark exceeded. Num events "

+            "on queue: %u\n",

+            queueName == NULL ? "" : queueName, size);

+}

+

+static void MAMACALLTYPE

+lowWaterMarkCallback  (mamaQueue     queue,

+                       size_t        size,

+                       void*         closure)

+{

+    mama_status status      = MAMA_STATUS_OK;

+    const char* queueName   = NULL;

+

+    if (queue)

+    {

+        if (MAMA_STATUS_OK!=(status=mamaQueue_getQueueName (queue, &queueName)))

+        {

+            fprintf (stderr, "Could not get queue name [%s]",

+                     mamaStatus_stringForStatus (status));

+        }

+    }

+    else /*Default queue*/

+    {

+        queueName = "DEFAULT_QUEUE";

+    }

+

+    printf ("%s low water mark exceeded. Num events on queue: %u\n",

+            queueName == NULL ? "" : queueName, size);

+}

+

+void setQueueMonitors (mamaQueue queue, int queueIndex)

+{

+    if (gHighWaterMark>0 || gLowWaterMark>0)

+    {

+        mamaQueueMonitorCallbacks queueCallbacks;

+        char                      queueNameBuf[10];

+        mama_status               status = MAMA_STATUS_OK;

+

+        snprintf (queueNameBuf, 10, "QUEUE %d", queueIndex);   

+

+        mamaQueue_setQueueName (queue, queueNameBuf);

+

+        queueCallbacks.onQueueHighWatermarkExceeded =

+            highWaterMarkCallback;

+        queueCallbacks.onQueueLowWatermark  =   lowWaterMarkCallback;

+

+        mamaQueue_setQueueMonitorCallbacks (queue,

+                                            &queueCallbacks,

+                                            NULL);

+

+        if (gHighWaterMark>0)

+        {

+            if (MAMA_STATUS_OK!=(status=mamaQueue_setHighWatermark

+                        (queue, gHighWaterMark)))

+            {

+                fprintf (stderr,

+                         "Could not set high water mark for queue %s. [%s]",

+                         queueNameBuf,

+                         mamaStatus_stringForStatus (status));

+            }

+        }

+

+        if (gLowWaterMark>0)

+        {

+            if (MAMA_STATUS_OK!=(status=mamaQueue_setLowWatermark

+                        (queue, gLowWaterMark)))

+            {

+                fprintf (stderr,

+                         "Could not set low water mark for queue %s. [%s]",

+                         queueNameBuf,

+                         mamaStatus_stringForStatus (status));

+            }

+        }

+    }

+    return;

+}

+

+/* mamalistencachedc specific methods */

+mama_status checkFieldIntegrityIds(mamaMsgField field, mamaFieldCache fieldCache, int *test)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaFieldType type = 0;

+    mamaFieldCacheField fieldCacheField = NULL;

+    const char* fieldName = NULL;

+    int localTest = 1;

+

+    mama_fid_t fieldId = 0;

+    ret = mamaMsgField_getFid(field, &fieldId);

+    if(ret == MAMA_STATUS_OK)

+    {

+        if(fieldId > WOMBAT_MAX_RESERVED_FID)

+        {

+            ret = mamaMsgField_getType(field, &type);

+            if(ret == MAMA_STATUS_OK)

+            {

+                mamaMsgField_getName(field, &fieldName);

+                ret = mamaFieldCache_find(fieldCache, fieldId, NULL, &fieldCacheField);

+                if(ret == MAMA_STATUS_OK)

+                {

+                    switch (type)

+                    {

+                    case MAMA_FIELD_TYPE_BOOL:

+                    {

+                        mama_bool_t cacheVal = -1, msgVal;

+                        mamaMsgField_getBool(field, &msgVal);

+                        mamaFieldCacheField_getBool(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_CHAR:

+                    {

+                        char cacheVal = '\0', msgVal;

+                        mamaMsgField_getChar(field, &msgVal);

+                        mamaFieldCacheField_getChar(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_I8:

+                    {

+                        mama_i8_t cacheVal = -1, msgVal;

+                        mamaMsgField_getI8(field, &msgVal);

+                        mamaFieldCacheField_getI8(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_U8:        

+                    {

+                        mama_u8_t cacheVal = 1, msgVal;

+                        mamaMsgField_getU8(field, &msgVal);

+                        mamaFieldCacheField_getU8(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }           

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_I16:

+                    {

+                        mama_i16_t cacheVal = -987, msgVal;

+                        mamaMsgField_getI16(field, &msgVal);

+                        mamaFieldCacheField_getI16(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_U16:

+                    {

+                        mama_u16_t cacheVal = 987, msgVal;

+                        mamaMsgField_getU16(field, &msgVal);

+                        mamaFieldCacheField_getU16(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_I32:

+                    {

+                        mama_i32_t cacheVal = -987, msgVal;

+                        mamaMsgField_getI32(field, &msgVal);

+                        mamaFieldCacheField_getI32(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_U32:

+                    {

+                        mama_u32_t cacheVal = 987, msgVal;

+                        mamaMsgField_getU32(field, &msgVal);

+                        mamaFieldCacheField_getU32(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %d, %d",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_I64:

+                    {

+                        mama_i64_t cacheVal = -987, msgVal;

+                        mamaMsgField_getI64(field, &msgVal);

+                        mamaFieldCacheField_getI64(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %"PRId64", %"PRId64,

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_U64:

+                    {

+                        mama_u64_t cacheVal = 987, msgVal;

+                        mamaMsgField_getU64(field, &msgVal);

+                        mamaFieldCacheField_getU64(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %"PRId64", %"PRId64,

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_F32:

+                    {

+                        mama_f32_t cacheVal = -1, msgVal;

+                        mamaMsgField_getF32(field, &msgVal);

+                        mamaFieldCacheField_getF32(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %f, %f",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_F64:

+                    {

+                        mama_f64_t cacheVal = -1, msgVal;

+                        mamaMsgField_getF64(field, &msgVal);

+                        ret = mamaFieldCacheField_getF64(fieldCacheField, &cacheVal);

+                        if (cacheVal != msgVal)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %g, %g",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_STRING:                          

+                    {

+                        const char *cacheVal = NULL, *msgVal = NULL;

+                        mama_size_t len = 0;

+                        mamaMsgField_getString(field, &msgVal);

+                        mamaFieldCacheField_getString(fieldCacheField, &cacheVal, &len);

+                        if (strcmp(cacheVal, msgVal) != 0)

+                        {

+                            printf ("\nThe Failed Field is %s and the values are %s, %s",

+                                fieldName,msgVal,cacheVal);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_TIME:

+                    {

+                        mamaDateTime cacheVal = NULL, msgVal = NULL;

+                        mama_u64_t msgValNumber, cacheValNumber;

+                        mamaMsgField_getDateTime(field, msgVal);

+                        mamaFieldCacheField_getDateTime(fieldCacheField, &cacheVal);

+                        if (mamaDateTime_equal(msgVal, cacheVal) != 0)

+                        {

+                            mamaDateTime_getEpochTimeMicroseconds(msgVal, &msgValNumber);

+                            mamaDateTime_getEpochTimeMicroseconds(cacheVal, &cacheValNumber);

+                            printf ("\nThe Failed Field is %s and the values are %"PRId64", %"PRId64,

+                                fieldName,msgValNumber,cacheValNumber);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    case MAMA_FIELD_TYPE_PRICE:

+                    { 

+                        mamaPrice cacheVal = NULL, msgVal = NULL;

+                        double msgValNumber, cacheValNumber;

+                        mamaMsgField_getPrice(field, &msgVal);

+                        mamaFieldCacheField_getPrice(fieldCacheField, &cacheVal);

+                        if (mamaPrice_equal(msgVal, cacheVal) != 0)

+                        {

+                            mamaPrice_getValue(msgVal, &msgValNumber);

+                            mamaPrice_getValue(cacheVal, &cacheValNumber);

+                            printf ("\nThe Failed Field is %s and the values are %f, %f",

+                                fieldName,msgValNumber,cacheValNumber);

+                            localTest = 0;

+                        }

+                        break;

+                    }

+                    default:

+                        printf("\nFailed: default");

+                        break;

+                    }

+                }

+                else

+                {

+                    printf("\nFailed: cannot find field in cache");

+                }

+            }

+            else

+            {

+                printf("\nFailed: cannot get field type for field");

+            }

+        }

+    }

+    else

+    {

+        printf("\nFailed: cannot get field if for field");

+    }

+

+    if(ret != MAMA_STATUS_OK)

+    {

+        localTest = 0;

+    }   

+

+    *test = localTest;

+

+    return ret;

+}

+

+mama_status checkSnapshotIntegrity(mamaFieldCache fieldCache, mamaMsg message)

+{   

+    /* Create a new iterator. */

+    mamaMsgIterator iterator = NULL;

+    mama_status ret = mamaMsgIterator_create(&iterator, gDictionary);

+    if(ret == MAMA_STATUS_OK)

+    {

+        /* Associate the iterator with the message. */

+        ret = mamaMsgIterator_associate(iterator, message);

+        if(ret == MAMA_STATUS_OK)

+        {

+            /* This flag will be set to 1 for each field that has passed the test. */

+            int test = 1;

+

+            /* Create an enumerator. */

+            mamaMsgField nextField = mamaMsgIterator_next(iterator);

+

+            printf("Field cache integrity check start.\n");

+   

+            /* Enumerate all the fields. */

+            while((nextField != NULL) && (ret == MAMA_STATUS_OK) && (test == 1))

+            {

+                /* Check the integrity of this field, if there is a dictionary then

+                 * this will be done using field names.

+                 */

+                ret = checkFieldIntegrityIds(nextField, fieldCache, &test);

+

+                /* Get the next field. */

+                nextField = mamaMsgIterator_next(iterator);

+            }

+

+            /* Print a message if all the tests passed. */

+            if(test == 0)

+            {

+                printf ("\ncheckSnapshotIntegrity: FAILED");

+            }

+            else

+            {

+                printf ("\ncheckSnapshotIntegrity: SUCCESSFUL");

+            }

+            printf("\nField cache integrity check end.\n");           

+        }

+

+        /* Destroy the iterator. */

+        {

+            mama_status error = mamaMsgIterator_destroy(iterator);

+            if(ret == MAMA_STATUS_OK)

+            {

+                ret = error;

+            }

+        }

+    }

+

+    return ret;

+}

+

+mama_status createFieldCaches(void)

+{

+    mama_status ret = MAMA_STATUS_NOMEM;

+    int cacheIndex = 0;

+

+    /* Allocate the array of field caches. */

+    gFieldCaches = (mamaFieldCache *)calloc(gNumSymbols, sizeof(mamaFieldCache));

+    if(gFieldCaches != NULL)

+    {

+        gFieldCacheIndexes = (int*)calloc(gNumSymbols, sizeof(int));

+        /* Enumerate the array and create each one in turn. */

+        cacheIndex = 0;

+        ret = MAMA_STATUS_OK;

+        while((ret == MAMA_STATUS_OK) && (cacheIndex<gNumSymbols))       

+        {

+            /* Create the cache with typical values and ensure that auto string format is on. */

+            ret = mamaFieldCache_create(&gFieldCaches[cacheIndex]);

+            mamaFieldCache_setUseLock(gFieldCaches[cacheIndex], 0);

+            gFieldCacheIndexes[cacheIndex] = cacheIndex;

+

+            /* Increment the loop counter. */

+            cacheIndex++;

+        }

+

+        /* If something went wrong then destroy the caches. */

+        if(ret != MAMA_STATUS_OK)

+        {

+            destroyFieldCaches();

+        }

+    }

+

+    return ret;

+}

+

+mama_status createVerificationTimer(mamaQueue queue, const char *symbol, int index)

+{

+    /* Returns. */

+    mama_status ret = MAMA_STATUS_OK;

+

+    /* If field cache data must be verified then create a timer that will obtain

+     * snapshot subscriptions at a regular interval.

+     */

+    if((gVerifyCache == 1) && (gVerifyInterval > 0))

+    {

+        /* Allocate a structure. */

+        PVerificationData data = calloc(1, sizeof(VerificationData));

+        ret = MAMA_STATUS_NOMEM;

+        if(data != NULL)

+        {

+            /* Save arguments in member variables. */

+            data->m_queue    = queue;

+            data->m_symbol   = strdup(symbol);

+            data->mIndex     = index;

+            {

+                /* Create the timer. */           

+                ret = mamaTimer_create(&data->m_timer, queue, verifyTimerCallback, gVerifyInterval, data);

+

+                /* If it didn't work then delete the data object. */

+                if(ret != MAMA_STATUS_OK)

+                {

+                    destroyVerificationTimer(data);

+                }

+            }

+        }

+    }  

+

+    return ret;

+}

+

+mama_status destroyFieldCaches(void)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    int cacheIndex = 0;

+

+    if(gFieldCaches != NULL)

+    {

+        return ret;

+    }

+

+    /* Enumerate the array and destroy each one in turn. */

+    for(cacheIndex=0; cacheIndex<gNumSymbols; cacheIndex++)

+    {

+        /* Destroy the cache and preserve the function return code. */

+        mamaFieldCache_destroy(gFieldCaches[cacheIndex]);

+    }

+

+    /* Free the array itself. */

+    free(gFieldCaches);

+    gFieldCaches = NULL;

+   

+    free(gFieldCacheIndexes);

+    gFieldCacheIndexes = NULL;

+

+    return ret;

+}

+

+void destroyVerificationTimer(PVerificationData data)

+{

+    /* Only continue if the data is valid. */

+    if(data != NULL)

+    {

+        /* Free the symbol. */

+        if(data->m_symbol != NULL)

+        {

+            free((void *)data->m_symbol);

+        }

+

+        /* Destroy the timer. */

+        if(data->m_timer != NULL)

+        {

+            mamaTimer_destroy(data->m_timer);

+        }

+

+        /* Delete the structure. */

+        free(data);

+    }

+}

+

+mama_status displayHeader(mamaMsg message, mamaSubscription subscription)

+{

+    mama_status ret = MAMA_STATUS_OK;

+

+    if(gQuietness < 2)

+    {

+        const char* source = NULL;

+        ret = mamaSubscription_getSource(subscription, &source);

+        if(ret == MAMA_STATUS_OK)

+        {

+            const char* symbol = NULL;

+            ret = mamaSubscription_getSymbol(subscription, &symbol);

+            if(ret == MAMA_STATUS_OK)

+            {

+                const char* issueSymbol = NULL;

+                ret = mamaMsg_getString(message, NULL, 305, &issueSymbol);

+                if(ret == MAMA_STATUS_OK)

+                {

+                    printf ("%s.%s.%s Type: %s Status %s \n",

+                           issueSymbol,

+                           source,

+                           symbol,

+                           mamaMsgType_stringForMsg(message),

+                           mamaMsgStatus_stringForMsg(message));

+                }

+            }

+        }

+    }

+

+    return ret;

+}

+

+

+mama_status printAllCacheFields(mamaFieldCache fieldCache)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaFieldCacheIterator cacheIterator = NULL;

+    mamaFieldCacheField field = NULL;

+    mama_size_t size = 0;

+

+    mamaFieldCache_getSize(fieldCache, &size);

+    printf("Cache size: %u\n", size);

+   

+    ret = mamaFieldCacheIterator_create(&cacheIterator, fieldCache);

+    while (mamaFieldCacheIterator_hasNext(cacheIterator))

+    {

+        field = mamaFieldCacheIterator_next(cacheIterator);

+        printField(field);

+    }

+   

+    mamaFieldCacheIterator_destroy(cacheIterator);

+    return ret;

+}

+/*

+mama_status printAllMessageFields(mamaFieldCache fieldCache, mamaMsg message)

+{

+    mama_status ret = MAMA_STATUS_OK;

+    mamaMsgIterator iterator = NULL;

+    mamaMsgField field = NULL;

+   

+    if (gPrintUsingName)

+    {

+        return MAMA_STATUS_INVALID_ARG;

+    }

+       

+    ret = mamaMsgIterator_create(&iterator, gDictionary);

+    ret = mamaMsgIterator_associate(iterator, message);

+    field = mamaMsgIterator_next(iterator);

+    while((field != NULL) && (ret == MAMA_STATUS_OK))

+    {

+        ret = printFieldUsingId(field, fieldCache);

+        field = mamaMsgIterator_next(iterator);               

+    }

+

+    mamaMsgIterator_destroy(iterator);

+    return ret;

+}

+*/

+void printField(mamaFieldCacheField field)

+{

+    mama_fid_t fid;

+    mamaFieldType type;

+    const char *typeName;

+    char valueChar;

+    const char* valueStr;

+    mama_bool_t valueBool;

+    mama_i8_t valueI8;

+    mama_u8_t valueU8;

+    mama_i16_t valueI16;

+    mama_u16_t valueU16;

+    mama_i32_t valueI32;

+    mama_u32_t valueU32;

+    mama_i64_t valueI64;

+    mama_u64_t valueU64;

+    mama_f32_t valueFloat;

+    mama_f64_t valueDouble;

+    mama_size_t strLen;

+    const char *fieldName = "";

+    mamaFieldDescriptor fieldDesc;

+    mama_bool_t modified = 0;

+   

+    if(gQuietness < 1)

+    {

+        char fieldBuffer[256] = "";

+

+        mamaFieldCacheField_getType(field, &type);

+        typeName = mamaFieldTypeToString(type);

+       

+        mamaFieldCacheField_getFid(field, &fid);

+       

+        mamaFieldCacheField_isModified(field, &modified);

+

+        if(gDictionary != NULL)

+        {

+            mamaDictionary_getFieldDescriptorByFid(gDictionary, &fieldDesc, fid);

+            fieldName = mamaFieldDescriptor_getName(fieldDesc);

+        }

+

+        sprintf(

+            fieldBuffer,

+            "  %-30s | %4d | %10s | %c | ",

+            fieldName,

+            fid,

+            typeName,

+            modified ? '*': ' ');

+        printf("%s", (const char*)fieldBuffer);

+

+        switch (type)

+        {

+        case MAMA_FIELD_TYPE_CHAR:

+            mamaFieldCacheField_getChar(field, &valueChar);

+            printf("%c\n", valueChar);

+            break;

+        case MAMA_FIELD_TYPE_BOOL:

+            mamaFieldCacheField_getBool(field, &valueBool);

+            printf("%d\n", valueBool);

+            break;

+        case MAMA_FIELD_TYPE_I8:

+            mamaFieldCacheField_getI8(field, &valueI8);

+            printf("%d\n", valueI8);

+            break;

+        case MAMA_FIELD_TYPE_U8:

+            mamaFieldCacheField_getU8(field, &valueU8);

+            printf("%d\n", valueU8);

+            break;

+        case MAMA_FIELD_TYPE_I16:

+            mamaFieldCacheField_getI16(field, &valueI16);

+            printf("%d\n", valueI16);

+            break;

+        case MAMA_FIELD_TYPE_U16:

+            mamaFieldCacheField_getU16(field, &valueU16);

+            printf("%d\n", valueU16);

+            break;

+        case MAMA_FIELD_TYPE_I32:

+            mamaFieldCacheField_getI32(field, &valueI32);

+            printf("%d\n", valueI32);

+            break;

+        case MAMA_FIELD_TYPE_U32:

+            mamaFieldCacheField_getU32(field, &valueU32);

+            printf("%d\n", valueU32);

+            break;

+        case MAMA_FIELD_TYPE_I64:

+            mamaFieldCacheField_getI64(field, &valueI64);

+            printf("%"PRId64"\n", valueI64);

+            break;

+        case MAMA_FIELD_TYPE_U64:

+            mamaFieldCacheField_getU64(field, &valueU64);

+            printf("%"PRId64"\n", valueU64);

+            break;

+        case MAMA_FIELD_TYPE_F32:

+            mamaFieldCacheField_getF32(field, &valueFloat);

+            printf("%f\n", valueFloat);

+            break;

+        case MAMA_FIELD_TYPE_F64:

+            mamaFieldCacheField_getF64(field, &valueDouble);

+            printf("%f\n", valueDouble);

+            break;

+        case MAMA_FIELD_TYPE_STRING:

+            mamaFieldCacheField_getString(field, &valueStr, &strLen);

+            printf("%s\n", valueStr);

+            break;

+        case MAMA_FIELD_TYPE_TIME:

+        {

+            const mamaDateTime result = NULL;

+            char         dateTimeString[56];

+            mamaFieldCacheField_getDateTime (field, &result);

+            mamaDateTime_getAsString (result,dateTimeString, 56);

+            printf ("%s\n", dateTimeString);

+            break;

+        }

+         case MAMA_FIELD_TYPE_PRICE:

+        {

+            const mamaPrice result = NULL;

+            char      priceString[56];

+            mamaFieldCacheField_getPrice (field, &result);

+            mamaPrice_getAsString (result, priceString, 56);

+            printf ("%s\n", priceString);

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I8:

+        {

+            const mama_i8_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getI8Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %d\n", (int)result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U8:

+        {

+            const mama_u8_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getU8Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %d\n", (unsigned int)result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I16:

+        {

+            const mama_i16_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getI16Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %d\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U16:

+        {

+            const mama_u16_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getU16Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %d\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I32:

+        {

+            const mama_i32_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getI32Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %d\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U32:

+        {

+            const mama_u32_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getU32Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %d\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_I64:

+        {

+            const mama_i64_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getI64Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %"PRId64"\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_U64:

+        {

+            const mama_u64_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getU64Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %"PRId64"\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F32:

+        {

+            const mama_f32_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getF32Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %f\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_F64:

+        {

+            const mama_f64_t* result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i =0;

+            mamaFieldCacheField_getF64Vector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("   %f\n", result[i]);

+            }

+            break;

+        }

+        case MAMA_FIELD_TYPE_VECTOR_STRING:

+        {

+            const char** result = NULL;

+            mama_size_t size = 0;

+            mama_size_t i;

+            mamaFieldCacheField_getStringVector(field,&result,&size);

+            printf("\n");

+            for (i=0;i<size;i++)

+            {

+                printf("    %s\n", result[i]);

+            }

+            break;

+        }

+        default:

+            break;

+        }

+    }

+}

+

+/*

+mama_status printFieldUsingId(mamaMsgField field, mamaFieldCache fieldCache)

+{

+    mama_status ret = MAMA_STATUS_OK;

+

+    mama_fid_t id = 0;

+    ret = mamaMsgField_getFid(field, &id);

+    if(ret == MAMA_STATUS_OK)

+    {

+        mamaFieldType type = 0;

+        ret = mamaMsgField_getType(field, &type);

+        if(ret == MAMA_STATUS_OK)

+        {

+            mamaFieldCacheField cacheField = NULL;

+            ret = mamaFieldCache_find(fieldCache, id, NULL, &cacheField);

+            if(ret == MAMA_STATUS_OK)

+            {

+                printField(cacheField);

+            }

+        }

+    }

+

+    return ret;

+}

+*/

+

+static void MAMACALLTYPE

+verifyTimerCallback(mamaTimer timer, void *closure)

+{  

+    /* Cast the closure to a data structure. */

+    PVerificationData verificationData = (PVerificationData)closure;

+

+    /* We verify the cache by creating a snapshot subscription, when the callback

+     * is received the contents of the snapshot will be compared against the cache.

+     */

+    mamaSubscription snapShotSubscription = NULL;

+    mama_status error = mamaSubscription_allocate(&snapShotSubscription);

+    if(error == MAMA_STATUS_OK)

+    {

+        /* Re-use all the existing callback functions. */

+        mamaMsgCallbacks callbacks;

+        memset(&callbacks, 0, sizeof(callbacks));

+        callbacks.onCreate          = subscriptionOnCreate;

+        callbacks.onError           = subscriptionOnError;

+        callbacks.onMsg             = subscriptionOnMsg;

+        callbacks.onQuality         = subscriptionOnQuality;   

+        callbacks.onGap             = NULL;

+        callbacks.onRecapRequest    = NULL;

+       

+        /* Set properties. */

+        mamaSubscription_setTimeout(snapShotSubscription, 10.0);

+        mamaSubscription_setRetries(snapShotSubscription, 3);

+        mamaSubscription_setRequiresInitial(snapShotSubscription, 1);

+       

+        /* Create the subscription, note that it will be deleted whenever it expires. */

+        mamaSubscription_createSnapshot(snapShotSubscription, verificationData->m_queue, &callbacks,

+                    gSubscriptionSource, verificationData->m_symbol, &verificationData->mIndex);

+    }

+}

diff --git a/mama/c_cpp/src/examples/c/mamalistencachedc.vcproj b/mama/c_cpp/src/examples/c/mamalistencachedc.vcproj

new file mode 100644

index 0000000..f068779

--- /dev/null

+++ b/mama/c_cpp/src/examples/c/mamalistencachedc.vcproj

@@ -0,0 +1,373 @@

+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+             ProjectType="Visual C++"

+             Version="8.00"

+             Name="mamalistencachedc"

+             ProjectGUID="{14EEBB9E-9A32-47DC-9371-8E450F4AA587}"

+             RootNamespace="mamalistencachedc_vc7"

+             Keyword="Win32Proj"

+             >

+             <Platforms>

+                             <Platform

+                                             Name="Win32"

+                             />

+             </Platforms>

+             <ToolFiles>

+             </ToolFiles>

+             <Configurations>

+                             <Configuration

+                                             Name="Dynamic-Debug|Win32"

+                                             OutputDirectory="$(ConfigurationName)"

+                                             IntermediateDirectory="$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                                             CharacterSet="0"

+                                             BuildLogFile="$(IntDir)\$(TargetName).htm"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             Optimization="0"

+                                                             AdditionalIncludeDirectories="$(API_HOME)\include"

+                                                             PreprocessorDefinitions="WIN32;"

+                                                             MinimalRebuild="true"

+                                                             BasicRuntimeChecks="3"

+                                                             RuntimeLibrary="3"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="4"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             AdditionalDependencies="libmamacmdd.lib ws2_32.lib"

+                                                             OutputFile="$(OutDir)/mamalistencachedc_vc7.exe"

+                                                             LinkIncremental="2"

+                                                             AdditionalLibraryDirectories="$(API_HOME)\lib\dynamic-debug"

+                                                             GenerateDebugInformation="true"

+                                                             ProgramDatabaseFile="$(OutDir)/mamalistencachedc_vc7.pdb"

+                                                             SubSystem="0"

+                                                             TargetMachine="0"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebDeploymentTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPostBuildEventTool"

+                                             />

+                             </Configuration>

+                             <Configuration

+                                             Name="Dynamic|Win32"

+                                             OutputDirectory="$(ConfigurationName)"

+                                             IntermediateDirectory="$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                                             CharacterSet="0"

+                                             BuildLogFile="$(IntDir)\$(TargetName).htm"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             AdditionalIncludeDirectories="$(API_HOME)\include"

+                                                             PreprocessorDefinitions="WIN32"

+                                                             RuntimeLibrary="2"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="3"

+                                                             CompileAs="1"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             AdditionalDependencies="libmamacmd.lib ws2_32.lib"

+                                                             OutputFile="$(OutDir)/mamalistencachedc_vc7.exe"

+                                                             LinkIncremental="1"

+                                                             AdditionalLibraryDirectories="$(API_HOME)\lib\dynamic"

+                                                             GenerateDebugInformation="true"

+                                                             SubSystem="0"

+                                                             OptimizeReferences="2"

+                                                             EnableCOMDATFolding="2"

+                                                             TargetMachine="1"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebDeploymentTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPostBuildEventTool"

+                                             />

+                             </Configuration>

+                             <Configuration

+                                             Name="Static|Win32"

+                                             OutputDirectory="$(ConfigurationName)"

+                                             IntermediateDirectory="$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                                             CharacterSet="0"

+                                             BuildLogFile="$(IntDir)\$(TargetName).htm"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             AdditionalIncludeDirectories="$(API_HOME)\include"

+                                                             PreprocessorDefinitions="WIN32; MAMA_STATIC"

+                                                             RuntimeLibrary="0"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="3"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             AdditionalDependencies="shlwapi.lib libwombatcommonmt.lib libwcachemt.lib libmamacmt.lib libwombatmsgmt.lib $(PLATFORM_LIB) ws2_32.lib"

+                                                             OutputFile="$(OutDir)/mamalistencachedc_vc7.exe"

+                                                             LinkIncremental="1"

+                                                             AdditionalLibraryDirectories="$(API_HOME)\lib\static"

+                                                             GenerateDebugInformation="true"

+                                                             SubSystem="0"

+                                                             OptimizeReferences="2"

+                                                             EnableCOMDATFolding="2"

+                                                             TargetMachine="0"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebDeploymentTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPostBuildEventTool"

+                                             />

+                             </Configuration>

+                             <Configuration

+                                             Name="Static-Debug|Win32"

+                                             OutputDirectory="$(ConfigurationName)"

+                                             IntermediateDirectory="$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                                             CharacterSet="0"

+                                             BuildLogFile="$(IntDir)\$(TargetName).htm"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             Optimization="0"

+                                                             AdditionalIncludeDirectories="$(API_HOME)\include"

+                                                             PreprocessorDefinitions="WIN32; MAMA_STATIC"

+                                                             MinimalRebuild="true"

+                                                             BasicRuntimeChecks="3"

+                                                             RuntimeLibrary="1"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="4"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             AdditionalDependencies="shlwapi.lib libwombatcommonmtd.lib libwcachemtd.lib libmamacmtd.lib libwombatmsgmtd.lib $(PLATFORM_LIB_DEBUG) ws2_32.lib"

+                                                             OutputFile="$(OutDir)/mamalistencachedc_vc7.exe"

+                                                             LinkIncremental="2"

+                                                             AdditionalLibraryDirectories="$(API_HOME)\lib\static-debug"

+                                                             IgnoreDefaultLibraryNames="LIBCMT"

+                                                             GenerateDebugInformation="true"

+                                                             ProgramDatabaseFile="$(OutDir)/mamalistencachedc_vc7.pdb"

+                                                             SubSystem="0"

+                                                             TargetMachine="0"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebDeploymentTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPostBuildEventTool"

+                                             />

+                             </Configuration>

+             </Configurations>

+             <References>

+             </References>

+             <Files>

+                             <Filter

+                                             Name="Source Files"

+                                             Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"

+                                             UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"

+                                             >

+                                             <File

+                                                             RelativePath=".\mamalistencachedc.c"

+                                                             >

+                                             </File>

+                             </Filter>

+                             <Filter

+                                             Name="Header Files"

+                                             Filter="h;hpp;hxx;hm;inl;inc;xsd"

+                                             UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"

+                                             >

+                             </Filter>

+                             <Filter

+                                             Name="Resource Files"

+                                             Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"

+                                             UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"

+                                             >

+                             </Filter>

+             </Files>

+             <Globals>

+             </Globals>

+</VisualStudioProject>

diff --git a/mama/c_cpp/src/examples/c/openmamalistencachedc.vcproj b/mama/c_cpp/src/examples/c/openmamalistencachedc.vcproj

new file mode 100644

index 0000000..4851f64

--- /dev/null

+++ b/mama/c_cpp/src/examples/c/openmamalistencachedc.vcproj

@@ -0,0 +1,365 @@

+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+             ProjectType="Visual C++"

+             Version="8.00"

+             Name="mamalistencachedc"

+             ProjectGUID="{77CDA662-CA86-4713-A549-4F1422BD44DA}"

+             RootNamespace="mamalistencachedc"

+             Keyword="Win32Proj"

+             >

+             <Platforms>

+                             <Platform

+                                             Name="Win32"

+                             />

+                             <Platform

+                                             Name="x64"

+                             />

+             </Platforms>

+             <ToolFiles>

+             </ToolFiles>

+             <Configurations>

+                             <Configuration

+                                             Name="Debug|Win32"

+                                             OutputDirectory="$(SolutionDir)$(ConfigurationName)"

+                                             IntermediateDirectory="$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             CharacterSet="1"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             Optimization="0"

+                                                             AdditionalIncludeDirectories="&quot;$(SOLUTIONDIR)\common\c_cpp\src\c\windows&quot;;&quot;$(SOLUTIONDIR)\common\c_cpp\src\c&quot;;&quot;$(SOLUTIONDIR)\mama\c_cpp\src\c&quot;"

+                                                             PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"

+                                                             MinimalRebuild="true"

+                                                             BasicRuntimeChecks="3"

+                                                             RuntimeLibrary="3"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="4"

+                                                             ForcedIncludeFiles="wombat/targetsxs.h"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             OutputFile="$(OutDir)\mamalistencachedc.exe"

+                                                             LinkIncremental="2"

+                                                             GenerateDebugInformation="true"

+                                                             SubSystem="1"

+                                                             TargetMachine="1"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebDeploymentTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPostBuildEventTool"

+                                             />

+                             </Configuration>

+                             <Configuration

+                                             Name="Release|Win32"

+                                             OutputDirectory="$(SolutionDir)$(ConfigurationName)"

+                                             IntermediateDirectory="$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             CharacterSet="1"

+                                             WholeProgramOptimization="1"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             AdditionalIncludeDirectories="&quot;$(SOLUTIONDIR)\common\c_cpp\src\c\windows&quot;;&quot;$(SOLUTIONDIR)\common\c_cpp\src\c&quot;;&quot;$(SOLUTIONDIR)\mama\c_cpp\src\c&quot;"

+                                                             PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"

+                                                             RuntimeLibrary="2"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="3"

+                                                             ForcedIncludeFiles="wombat/targetsxs.h"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             LinkIncremental="1"

+                                                             GenerateDebugInformation="true"

+                                                             SubSystem="1"

+                                                             OptimizeReferences="2"

+                                                             EnableCOMDATFolding="2"

+                                                             TargetMachine="1"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebDeploymentTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPostBuildEventTool"

+                                             />

+                             </Configuration>

+                             <Configuration

+                                             Name="Debug|x64"

+                                             OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"

+                                             IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"

+                                             ConfigurationType="1"

+                                             CharacterSet="1"

+                                             >

+                                             <Tool

+                                                             Name="VCPreBuildEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCCustomBuildTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXMLDataGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCWebServiceProxyGeneratorTool"

+                                             />

+                                             <Tool

+                                                             Name="VCMIDLTool"

+                                                             TargetEnvironment="3"

+                                             />

+                                             <Tool

+                                                             Name="VCCLCompilerTool"

+                                                             Optimization="0"

+                                                             AdditionalIncludeDirectories="&quot;$(SOLUTIONDIR)\common\c_cpp\src\c\windows&quot;;&quot;$(SOLUTIONDIR)\common\c_cpp\src\c&quot;;&quot;$(SOLUTIONDIR)\mama\c_cpp\src\c&quot;"

+                                                             PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"

+                                                             MinimalRebuild="true"

+                                                             BasicRuntimeChecks="3"

+                                                             RuntimeLibrary="3"

+                                                             UsePrecompiledHeader="0"

+                                                             WarningLevel="3"

+                                                             Detect64BitPortabilityProblems="true"

+                                                             DebugInformationFormat="3"

+                                                             ForcedIncludeFiles="wombat/targetsxs.h"

+                                             />

+                                             <Tool

+                                                             Name="VCManagedResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCResourceCompilerTool"

+                                             />

+                                             <Tool

+                                                             Name="VCPreLinkEventTool"

+                                             />

+                                             <Tool

+                                                             Name="VCLinkerTool"

+                                                             LinkIncremental="2"

+                                                             GenerateDebugInformation="true"

+                                                             SubSystem="1"

+                                                             TargetMachine="17"

+                                             />

+                                             <Tool

+                                                             Name="VCALinkTool"

+                                             />

+                                             <Tool

+                                                             Name="VCManifestTool"

+                                             />

+                                             <Tool

+                                                             Name="VCXDCMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCBscMakeTool"

+                                             />

+                                             <Tool

+                                                             Name="VCFxCopTool"

+                                             />

+                                             <Tool

+                                                             Name="VCAppVerifierTool"

+                                             />

+                                             <Tool

+