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


Damian Maguire <DMaguire@...>
 

Afternoon folks,

Just wanted to let you know that I've added the field cache code as a feature branch off next, feature-fieldcache. I've also raised a Bugzilla for tracking the changes through to release -  http://bugs.openmama.org/show_bug.cgi?id=83  

Gary, you mentioned you might have some additional changes to throw in, so if you want to fire those across when they're ready I'll get them added to the branch. 

Any questions let me know.

Cheers, 

D

From: Damian Maguire <dmaguire@...>
Date: Thursday, April 3, 2014 11:33 AM
To: Gary Molloy <GMolloy@...>, "openmama-dev@..." <openmama-dev@...>
Subject: Re: [Openmama-dev] [PATCH] OpenSource MamaFieldCache in MAMA 6 - C/CPP

Cheers Gary, looks really good. I'll get this merged into a feature branch and let you know when it's available. We can take the testing and everything from there.

Thanks, 

Damian

From: Gary Molloy <GMolloy@...>
Date: Thursday, April 3, 2014 9:54 AM
To: "openmama-dev@..." <openmama-dev@...>
Subject: Re: [Openmama-dev] [PATCH] OpenSource MamaFieldCache in MAMA 6 - C/CPP

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@...>

---



This message may contain confidential information and is intended for specific recipients unless explicitly noted otherwise. If you have reason to believe you are not an intended recipient of this message, please delete it and notify the sender. This message may not represent the opinion of IntercontinentalExchange Group, Inc. (ICE), NYSE Euronext or any of their subsidiaries or affiliates, and does not constitute a contract or guarantee. Unencrypted electronic mail is not secure and the recipient of this message is expected to provide safeguards from viruses and pursue alternate means of communication where privacy or a binding message is desired.

This message may contain confidential information and is intended for specific recipients unless explicitly noted otherwise. If you have reason to believe you are not an intended recipient of this message, please delete it and notify the sender. This message may not represent the opinion of IntercontinentalExchange Group, Inc. (ICE), NYSE Euronext or any of their subsidiaries or affiliates, and does not constitute a contract or guarantee. Unencrypted electronic mail is not secure and the recipient of this message is expected to provide safeguards from viruses and pursue alternate means of communication where privacy or a binding message is desired.


Damian Maguire <DMaguire@...>
 

Cheers Gary, looks really good. I'll get this merged into a feature branch and let you know when it's available. We can take the testing and everything from there.

Thanks, 

Damian

From: Gary Molloy <GMolloy@...>
Date: Thursday, April 3, 2014 9:54 AM
To: "openmama-dev@..." <openmama-dev@...>
Subject: Re: [Openmama-dev] [PATCH] OpenSource MamaFieldCache in MAMA 6 - C/CPP

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@...>

---



This message may contain confidential information and is intended for specific recipients unless explicitly noted otherwise. If you have reason to believe you are not an intended recipient of this message, please delete it and notify the sender. This message may not represent the opinion of IntercontinentalExchange Group, Inc. (ICE), NYSE Euronext or any of their subsidiaries or affiliates, and does not constitute a contract or guarantee. Unencrypted electronic mail is not secure and the recipient of this message is expected to provide safeguards from viruses and pursue alternate means of communication where privacy or a binding message is desired.


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"

+