Creating a branch for experimenting with some ideas for JMS client.rajith_jms_client

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/rajith_jms_client@1128369 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 1852 insertions, 0 deletions

diff --git a/qpid/cpp/managementgen/qmfgen/schema.py b/qpid/cpp/managementgen/qmfgen/schema.py
new file mode 100755
index 0000000000..59e951fb6e
--- /dev/null
+++ b/qpid/cpp/managementgen/qmfgen/schema.py
@@ -0,0 +1,1852 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+from xml.dom.minidom import parse, parseString, Node
+from cStringIO       import StringIO
+#import md5
+try:
+    import hashlib
+    _md5Obj = hashlib.md5
+except ImportError:
+    import md5
+    _md5Obj = md5.new
+
+class Hash:
+  """ Manage the hash of an XML sub-tree """
+  def __init__(self, node):
+    self.md5Sum = _md5Obj()
+    self._compute(node)
+
+  def addSubHash(self, hash):
+    """ Use this method to add the hash of a dependend-on XML fragment that is not in the sub-tree """
+    self.md5Sum.update(hash.getDigest())
+
+  def getDigest(self):
+    return self.md5Sum.digest()
+
+  def _compute(self, node):
+    attrs = node.attributes
+    self.md5Sum.update(node.nodeName)
+
+    for idx in range(attrs.length):
+      self.md5Sum.update(attrs.item(idx).nodeName)
+      self.md5Sum.update(attrs.item(idx).nodeValue)
+
+    for child in node.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        self._compute(child)
+
+
+#=====================================================================================
+#
+#=====================================================================================
+class SchemaType:
+  def __init__ (self, node):
+    self.name      = None
+    self.base      = None
+    self.cpp       = None
+    self.encode    = None
+    self.decode    = None
+    self.style     = "normal"
+    self.stream    = "#"
+    self.size      = "1"
+    self.accessor  = None
+    self.init      = "0"
+    self.perThread = False
+    self.byRef     = False
+    self.unmap     = "#"
+    self.map       = "#"
+
+    attrs = node.attributes
+    for idx in range (attrs.length):
+      key = attrs.item(idx).nodeName
+      val = attrs.item(idx).nodeValue
+      if   key == 'name':
+        self.name = val
+
+      elif key == 'base':
+        self.base = val
+
+      elif key == 'cpp':
+        self.cpp = val
+
+      elif key == 'encode':
+        self.encode = val
+
+      elif key == 'decode':
+        self.decode = val
+
+      elif key == 'style':
+        self.style = val
+
+      elif key == 'stream':
+        self.stream = val
+
+      elif key == 'size':
+        self.size = val
+
+      elif key == 'accessor':
+        self.accessor = val
+
+      elif key == 'init':
+        self.init = val
+
+      elif key == 'perThread':
+        if val != 'y':
+          raise ValueError ("Expected 'y' in perThread attribute")
+        self.perThread = True
+
+      elif key == 'byRef':
+        if val != 'y':
+          raise ValueError ("Expected 'y' in byRef attribute")
+        self.byRef = True
+
+      elif key == 'unmap':
+        self.unmap = val
+
+      elif key == 'map':
+        self.map = val
+
+      else:
+        raise ValueError ("Unknown attribute in type '%s'" % key)
+
+    if self.name == None or self.base == None or self.cpp == None or \
+       self.encode == None or self.decode == None:
+      raise ValueError ("Missing required attribute(s) in type")
+
+    if self.byRef:
+      self.asArg = "const " + self.cpp + "&"
+    else:
+      self.asArg = self.cpp
+
+  def getName (self):
+    return self.name
+
+  def genAccessor (self, stream, varName, changeFlag = None, optional = False):
+    if self.perThread:
+      prefix = "getThreadStats()->"
+      if self.style == "wm":
+        raise ValueError ("'wm' style types can't be per-thread")
+    else:
+      prefix = ""
+    if self.accessor == "direct":
+      stream.write ("    inline void set_" + varName + " (" + self.asArg + " val) {\n");
+      if not self.perThread:
+        stream.write ("        ::qpid::management::Mutex::ScopedLock mutex(accessLock);\n")
+      if self.style != "mma":
+        stream.write ("        " + prefix + varName + " = val;\n")
+        if optional:
+          stream.write ("        presenceMask[presenceByte_%s] |= presenceMask_%s;\n" % (varName, varName))
+      if self.style == "wm":
+        stream.write ("        if (" + varName + "Low  > val)\n")
+        stream.write ("            " + varName + "Low  = val;\n")
+        stream.write ("        if (" + varName + "High < val)\n")
+        stream.write ("            " + varName + "High = val;\n")
+      if self.style == "mma":
+        stream.write ("        " + prefix + varName + "Count++;\n")
+        stream.write ("        " + prefix + varName + "Total += val;\n")
+        stream.write ("        if (" + prefix + varName + "Min > val)\n")
+        stream.write ("            " + prefix + varName + "Min = val;\n")
+        stream.write ("        if (" + prefix + varName + "Max < val)\n")
+        stream.write ("            " + prefix + varName + "Max = val;\n")
+      if changeFlag != None:
+        stream.write ("        " + changeFlag + " = true;\n")
+      stream.write ("    }\n")
+      if self.style != "mma":
+        stream.write ("    inline " + self.asArg + " get_" + varName + "() {\n");
+        if not self.perThread:
+          stream.write ("        ::qpid::management::Mutex::ScopedLock mutex(accessLock);\n")
+        stream.write ("        return " + prefix + varName + ";\n")
+        stream.write ("    }\n")
+      if optional:
+        stream.write ("    inline void clr_" + varName + "() {\n")
+        stream.write ("        presenceMask[presenceByte_%s] &= ~presenceMask_%s;\n" % (varName, varName))
+        if changeFlag != None:
+          stream.write ("        " + changeFlag + " = true;\n")
+        stream.write ("    }\n")
+        stream.write ("    inline bool isSet_" + varName + "() {\n")
+        stream.write ("        return (presenceMask[presenceByte_%s] & presenceMask_%s) != 0;\n" % (varName, varName))
+        stream.write ("    }\n")
+    elif self.accessor == "counter":
+      stream.write ("    inline void inc_" + varName + " (" + self.asArg + " by = 1) {\n");
+      if not self.perThread:
+        stream.write ("        ::qpid::management::Mutex::ScopedLock mutex(accessLock);\n")
+      stream.write ("        " + prefix + varName + " += by;\n")
+      if self.style == "wm":
+        stream.write ("        if (" + varName + "High < " + varName + ")\n")
+        stream.write ("            " + varName + "High = " + varName + ";\n")
+      if changeFlag != None:
+        stream.write ("        " + changeFlag + " = true;\n")
+      stream.write ("    }\n");
+      stream.write ("    inline void dec_" + varName + " (" + self.asArg + " by = 1) {\n");
+      if not self.perThread:
+        stream.write ("        ::qpid::management::Mutex::ScopedLock mutex(accessLock);\n")
+      stream.write ("        " + prefix + varName + " -= by;\n")
+      if self.style == "wm":
+        stream.write ("        if (" + varName + "Low > " + varName + ")\n")
+        stream.write ("            " + varName + "Low = " + varName + ";\n")
+      if changeFlag != None:
+        stream.write ("        " + changeFlag + " = true;\n")
+      stream.write ("    }\n");
+
+  def genHiLoStatResets (self, stream, varName):
+    if self.style == "wm":
+      stream.write ("    " + varName + "High = " + varName + ";\n")
+      stream.write ("    " + varName + "Low  = " + varName + ";\n")
+    if self.style == "mma":
+      stream.write ("    " + varName + "Count = 0;\n")
+      stream.write ("    " + varName + "Total = 0;\n")
+      stream.write ("    " + varName + "Min   = std::numeric_limits<" + self.type.type.cpp + ">::max();\n")
+      stream.write ("    " + varName + "Max   = std::numeric_limits<" + self.type.type.cpp + ">::min();\n")
+
+  def genPerThreadHiLoStatResets (self, stream, varName, cpptype):
+    if self.style == "mma":
+      stream.write ("        threadStats->" + varName + "Count = 0;\n")
+      stream.write ("        threadStats->" + varName + "Total = 0;\n")
+      stream.write ("        threadStats->" + varName + "Min   = std::numeric_limits<" + cpptype + ">::max();\n")
+      stream.write ("        threadStats->" + varName + "Max   = std::numeric_limits<" + cpptype + ">::min();\n")
+
+  def genRead (self, stream, varName, indent="    "):
+    stream.write(indent + self.decode.replace("@", "buf").replace("#", varName) + ";\n")
+
+  def genUnmap (self, stream, varName, indent="    ", key=None, mapName="_map",
+                _optional=False):
+    if key is None:
+      key = varName
+    stream.write(indent + "if ((_i = " + mapName + ".find(\"" + key + "\")) != " + mapName + ".end()) {\n")
+    stream.write(indent + "    " + varName + " = " +
+                 self.unmap.replace("#", "_i->second") + ";\n")
+    if _optional:
+        stream.write(indent + "    _found = true;\n")
+    stream.write(indent + "}\n")
+
+  def genWrite (self, stream, varName, indent="    "):
+    if self.style != "mma":
+      stream.write (indent + self.encode.replace ("@", "buf").replace ("#", varName) + ";\n")
+    if self.style == "wm":
+      stream.write (indent + self.encode.replace ("@", "buf") \
+                    .replace ("#", varName + "High") + ";\n")
+      stream.write (indent + self.encode.replace ("@", "buf") \
+                    .replace ("#", varName + "Low") + ";\n")
+    if self.style == "mma":
+      stream.write (indent + self.encode.replace ("@", "buf") \
+                    .replace ("#", varName + "Count") + ";\n")
+      stream.write (indent + self.encode.replace ("@", "buf") \
+                    .replace ("#", varName + "Count ? " + varName + "Min : 0") + ";\n")
+      stream.write (indent + self.encode.replace ("@", "buf") \
+                    .replace ("#", varName + "Max") + ";\n")
+      stream.write (indent + self.encode.replace ("@", "buf") \
+                    .replace ("#", varName + "Count ? " + varName + "Total / " +
+                              varName + "Count : 0") + ";\n")
+
+  def genMap (self, stream, varName, indent="    ", key=None, mapName="_map"):
+    if key is None:
+      key = varName
+    if self.style != "mma":
+        var_cast = self.map.replace("#", varName)
+        stream.write(indent + mapName + "[\"" + key + "\"] = ::qpid::types::Variant(" + var_cast + ");\n")
+    if self.style == "wm":
+        var_cast_hi = self.map.replace("#", varName + "High")
+        var_cast_lo = self.map.replace("#", varName + "Low")
+        stream.write(indent + mapName + "[\"" + key + "High\"] = " +
+                     "::qpid::types::Variant(" + var_cast_hi + ");\n")
+        stream.write(indent + mapName + "[\"" + key + "Low\"] = " +
+                     "::qpid::types::Variant(" + var_cast_lo + ");\n")
+    if self.style == "mma":
+        var_cast = self.map.replace("#", varName + "Count")
+        stream.write(indent + mapName + "[\"" + key + "Count\"] = " + "::qpid::types::Variant(" + var_cast + ");\n")
+        var_cast = self.map.replace("#", varName + "Min")
+        stream.write(indent + mapName + "[\"" + key + "Min\"] = " +
+                     "(" + varName + "Count ? ::qpid::types::Variant(" + var_cast + ") : ::qpid::types::Variant(0));\n")
+        var_cast = self.map.replace("#", varName + "Max")
+        stream.write(indent + mapName + "[\"" + key + "Max\"] = " + "::qpid::types::Variant(" + var_cast + ");\n")
+
+        var_cast = self.map.replace("#", "(" + varName + "Total / " + varName + "Count)")
+        stream.write(indent + mapName + "[\"" + key + "Avg\"] = " +
+                     "(" + varName + "Count ? ::qpid::types::Variant(" + var_cast + ") : ::qpid::types::Variant(0));\n")
+
+  def getReadCode (self, varName, bufName):
+    result = self.decode.replace ("@", bufName).replace ("#", varName)
+    return result
+
+  def getWriteCode (self, varName, bufName):
+    result = self.encode.replace ("@", bufName).replace ("#", varName)
+    return result
+
+#=====================================================================================
+#
+#=====================================================================================
+class TypeSpec:
+  def __init__ (self, file):
+    self.types = {}
+    dom = parse (file)
+    document = dom.documentElement
+    if document.tagName != 'schema-types':
+      raise ValueError ("Expected 'schema-types' in type file")
+
+    for child in document.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        if child.nodeName == 'type':
+          stype = SchemaType (child)
+          self.types[stype.getName ()] = stype
+        else:
+          raise ValueError ("Unknown type tag '%s'" % child.nodeName)
+
+  def getType (self, name):
+    return self.types[name]
+
+
+#=====================================================================================
+#
+#=====================================================================================
+class Type:
+  def __init__ (self, name, typespec):
+    self.type = typespec.getType (name)
+
+#=====================================================================================
+#
+#=====================================================================================
+class SchemaProperty:
+  def __init__ (self, node, typespec):
+    self.name         = None
+    self.type         = None
+    self.ref          = None
+    self.access       = "RO"
+    self.isIndex      = 0
+    self.isParentRef  = 0
+    self.isGeneralRef = 0
+    self.isOptional   = 0
+    self.unit         = None
+    self.min          = None
+    self.max          = None
+    self.maxLen       = None
+    self.desc         = None
+
+    attrs = node.attributes
+    for idx in range (attrs.length):
+      key = attrs.item(idx).nodeName
+      val = attrs.item(idx).nodeValue
+      if   key == 'name':
+        self.name = makeValidCppSymbol(val)
+
+      elif key == 'type':
+        self.type = Type (val, typespec)
+        if self.type.type.accessor != 'direct':
+          raise ValueError ("Class properties must have a type with a direct accessor")
+
+      elif key == 'references':
+        self.ref = val
+        
+      elif key == 'access':
+        self.access = val
+        
+      elif key == 'index':
+        if val != 'y':
+          raise ValueError ("Expected 'y' in index attribute")
+        self.isIndex = 1
+        
+      elif key == 'parentRef':
+        if val != 'y':
+          raise ValueError ("Expected 'y' in parentRef attribute")
+        self.isParentRef = 1
+        
+      elif key == 'isGeneralReference':
+        if val != 'y':
+          raise ValueError ("Expected 'y' in isGeneralReference attribute")
+        self.isGeneralRef = 1
+        
+      elif key == 'optional':
+        if val != 'y':
+          raise ValueError ("Expected 'y' in optional attribute")
+        self.isOptional = 1
+        
+      elif key == 'unit':
+        self.unit = val
+        
+      elif key == 'min':
+        self.min = val
+        
+      elif key == 'max':
+        self.max = val
+        
+      elif key == 'maxlen':
+        self.maxLen = val
+        
+      elif key == 'desc':
+        self.desc = val
+        
+      else:
+        raise ValueError ("Unknown attribute in property '%s'" % key)
+
+    if self.access == "RC" and self.isOptional == 1:
+      raise ValueError ("Properties with ReadCreate access must not be optional (%s)" % self.name)
+
+    if self.name == None:
+      raise ValueError ("Missing 'name' attribute in property")
+    if self.type == None:
+      raise ValueError ("Missing 'type' attribute in property")
+
+  def getName (self):
+    return self.name
+
+  def isConstructorArg (self):
+    if self.access == "RC" and self.isParentRef == 0:
+      return 1
+    return 0
+
+  def genDeclaration (self, stream, prefix="    "):
+    stream.write (prefix + self.type.type.cpp + " " + self.name + ";\n")
+
+  def genFormalParam (self, stream, variables):
+    stream.write (self.type.type.asArg + " _" + self.name)
+
+  def genAccessor (self, stream):
+    self.type.type.genAccessor (stream, self.name, "configChanged", self.isOptional == 1)
+
+  def genInitialize (self, stream, prefix="", indent="    "):
+    val = self.type.type.init
+    stream.write (indent + prefix + self.name + " = " + val + ";\n")
+
+  def genSchema (self, stream):
+    stream.write ("    ft.clear();\n")
+    stream.write ("    ft[NAME] = \"" + self.name + "\";\n")
+    stream.write ("    ft[TYPE] = TYPE_" + self.type.type.base +";\n")
+    stream.write ("    ft[ACCESS] = ACCESS_" + self.access + ";\n")
+    stream.write ("    ft[IS_INDEX] = " + str (self.isIndex) + ";\n")
+    stream.write ("    ft[IS_OPTIONAL] = " + str (self.isOptional) + ";\n")
+    if self.unit != None:
+      stream.write ("    ft[UNIT] = \"" + self.unit   + "\";\n")
+    if self.min != None:
+      stream.write ("    ft[MIN] = " + self.min    + ";\n")
+    if self.max != None:
+      stream.write ("    ft[MAX] = " + self.max    + ";\n")
+    if self.maxLen != None:
+      stream.write ("    ft[MAXLEN] = " + self.maxLen + ";\n")
+    if self.desc != None:
+      stream.write ("    ft[DESC] = \"" + self.desc   + "\";\n")
+    stream.write ("    buf.putMap(ft);\n\n")
+
+
+  def genSchemaMap(self, stream):
+    stream.write ("    {\n")
+    stream.write ("        ::qpid::types::Variant::Map _value;\n")
+    stream.write ("        _value[TYPE] = TYPE_" + self.type.type.base +";\n")
+    stream.write ("        _value[ACCESS] = ACCESS_" + self.access + ";\n")
+    stream.write ("        _value[IS_INDEX] = " + str (self.isIndex) + ";\n")
+    stream.write ("        _value[IS_OPTIONAL] = " + str (self.isOptional) + ";\n")
+    if self.unit != None:
+      stream.write ("        _value[UNIT] = \"" + self.unit + "\";\n")
+    if self.min != None:
+      stream.write ("        _value[MIN] = " + self.min + ";\n")
+    if self.max != None:
+      stream.write ("        _value[MAX] = " + self.max + ";\n")
+    if self.maxLen != None:
+      stream.write ("        _value[MAXLEN] = " + self.maxLen + ";\n")
+    if self.desc != None:
+      stream.write ("        _value[DESC] = \"" + self.desc + "\";\n")
+    stream.write ("        _props[\"" + self.name + "\"] = _value;\n")
+    stream.write ("    }\n\n")
+
+
+
+  def genSize (self, stream):
+    indent = "    "
+    if self.isOptional:
+      stream.write("    if (presenceMask[presenceByte_%s] & presenceMask_%s) {\n" % (self.name, self.name))
+      indent = "        "
+    stream.write("%ssize += %s;  // %s\n" % (indent, self.type.type.size.replace("#", self.name), self.name))
+    if self.isOptional:
+      stream.write("    }\n")
+
+  def genRead (self, stream):
+    indent = "    "
+    if self.isOptional:
+      stream.write("    if (presenceMask[presenceByte_%s] & presenceMask_%s) {\n" % (self.name, self.name))
+      indent = "        "
+    self.type.type.genRead (stream, self.name, indent)
+    if self.isOptional:
+      stream.write("    }\n")
+
+  def genWrite (self, stream):
+    indent = "    "
+    if self.isOptional:
+      stream.write("    if (presenceMask[presenceByte_%s] & presenceMask_%s) {\n" % (self.name, self.name))
+      indent = "        "
+    self.type.type.genWrite (stream, self.name, indent)
+    if self.isOptional:
+      stream.write("    }\n")
+
+  def genUnmap (self, stream):
+    indent = "    "
+    if self.isOptional:
+      stream.write("    _found = false;\n")
+    self.type.type.genUnmap (stream, self.name, indent, _optional=self.isOptional)
+    if self.isOptional:
+      stream.write("    if (_found) {\n")
+      stream.write("        presenceMask[presenceByte_%s] |= presenceMask_%s;\n" %
+                   (self.name, self.name))
+      stream.write("    }\n")
+
+  def genMap (self, stream):
+    indent = "    "
+    if self.isOptional:
+      stream.write("    if (presenceMask[presenceByte_%s] & presenceMask_%s) {\n" % (self.name, self.name))
+      indent = "        "
+    self.type.type.genMap (stream, self.name, indent)
+    if self.isOptional:
+      stream.write("    }\n")
+
+
+  def __repr__(self):
+    m = {}
+    m["name"] = self.name
+    m["type"] = self.type
+    m["ref"] = self.ref
+    m["access"] = self.access
+    m["isIndex"] = self.isIndex
+    m["isParentRef"] = self.isParentRef
+    m["isGeneralRef"] = self.isGeneralRef
+    m["isOptional"] = self.isOptional
+    m["unit"] = self.unit
+    m["min"] = self.min
+    m["max"] = self.max
+    m["maxLen"] = self.maxLen
+    m["desc"] = self.desc
+    return str(m)
+
+#=====================================================================================
+#
+#=====================================================================================
+class SchemaStatistic:
+  def __init__ (self, node, typespec):
+    self.name   = None
+    self.type   = None
+    self.unit   = None
+    self.desc   = None
+    self.assign = None
+
+    attrs = node.attributes
+    for idx in range (attrs.length):
+      key = attrs.item(idx).nodeName
+      val = attrs.item(idx).nodeValue
+      if   key == 'name':
+        self.name = makeValidCppSymbol(val)
+
+      elif key == 'type':
+        self.type = Type (val, typespec)
+        
+      elif key == 'unit':
+        self.unit = val
+        
+      elif key == 'desc':
+        self.desc = val
+        
+      elif key == 'assign':
+        self.assign = val
+        
+      else:
+        raise ValueError ("Unknown attribute in statistic '%s'" % key)
+
+    if self.name == None:
+      raise ValueError ("Missing 'name' attribute in statistic")
+    if self.type == None:
+      raise ValueError ("Missing 'type' attribute in statistic")
+
+  def getName (self):
+    return self.name
+
+  def genDeclaration (self, stream, prefix="    "):
+    if self.type.type.style != "mma":
+      stream.write (prefix + self.type.type.cpp + "  " + self.name + ";\n")
+    if self.type.type.style == 'wm':
+      stream.write (prefix + self.type.type.cpp + "  " + self.name + "High;\n")
+      stream.write (prefix + self.type.type.cpp + "  " + self.name + "Low;\n")
+    if self.type.type.style == "mma":
+      stream.write (prefix + self.type.type.cpp + "  " + self.name + "Count;\n")
+      stream.write (prefix + "uint64_t  " + self.name + "Total;\n")
+      stream.write (prefix + self.type.type.cpp + "  " + self.name + "Min;\n")
+      stream.write (prefix + self.type.type.cpp + "  " + self.name + "Max;\n")
+
+  def genAccessor (self, stream):
+    self.type.type.genAccessor (stream, self.name, "instChanged")
+
+  def genHiLoStatResets (self, stream):
+    self.type.type.genHiLoStatResets (stream, self.name)
+
+  def genPerThreadHiLoStatResets (self, stream):
+    self.type.type.genPerThreadHiLoStatResets (stream, self.name, self.type.type.cpp)
+
+  def genSchemaText (self, stream, name, desc):
+    stream.write ("    ft.clear();\n")
+    stream.write ("    ft[NAME] = \"" + name + "\";\n")
+    stream.write ("    ft[TYPE] = TYPE_" + self.type.type.base +";\n")
+    if self.unit != None:
+      stream.write ("    ft[UNIT] = \"" + self.unit   + "\";\n")
+    if desc != None:
+      stream.write ("    ft[DESC] = \"" + desc   + "\";\n")
+    stream.write ("    buf.putMap(ft);\n\n")
+
+  def genSchemaTextMap(self, stream, name, desc):
+    stream.write ("    {\n")
+    stream.write ("        ::qpid::types::Variant::Map _value;\n")
+    stream.write ("        _value[TYPE] = TYPE_" + self.type.type.base +";\n")
+    if self.unit != None:
+      stream.write ("        _value[UNIT] = \"" + self.unit + "\";\n")
+    if desc != None:
+      stream.write ("        _value[DESC] = \"" + desc + "\";\n")
+    stream.write ("        _stats[\"" + self.name + "\"] = _value;\n")
+    stream.write ("    }\n\n")
+
+  def genSchema (self, stream):
+    if self.type.type.style != "mma":
+      self.genSchemaText (stream, self.name, self.desc)
+    if self.type.type.style == "wm":
+      descHigh = self.desc
+      descLow  = self.desc
+      if self.desc != None:
+        descHigh = descHigh + " (High)"
+        descLow  = descLow  + " (Low)"
+      self.genSchemaText (stream, self.name + "High", descHigh)
+      self.genSchemaText (stream, self.name + "Low",  descLow)
+    if self.type.type.style == "mma":
+      descCount   = self.desc
+      descMin     = self.desc
+      descMax     = self.desc
+      descAverage = self.desc
+      if self.desc != None:
+        descCount   = descCount   + " (Samples)"
+        descMin     = descMin     + " (Min)"
+        descMax     = descMax     + " (Max)"
+        descAverage = descAverage + " (Average)"
+      self.genSchemaText (stream, self.name + "Samples", descCount)
+      self.genSchemaText (stream, self.name + "Min",     descMin)
+      self.genSchemaText (stream, self.name + "Max",     descMax)
+      self.genSchemaText (stream, self.name + "Average", descAverage)
+
+  def genSchemaMap (self, stream):
+    if self.type.type.style != "mma":
+      self.genSchemaTextMap (stream, self.name, self.desc)
+    if self.type.type.style == "wm":
+      descHigh = self.desc
+      descLow  = self.desc
+      if self.desc != None:
+        descHigh = descHigh + " (High)"
+        descLow  = descLow  + " (Low)"
+      self.genSchemaTextMap (stream, self.name + "High", descHigh)
+      self.genSchemaTextMap (stream, self.name + "Low",  descLow)
+    if self.type.type.style == "mma":
+      descCount   = self.desc
+      descMin     = self.desc
+      descMax     = self.desc
+      descAverage = self.desc
+      if self.desc != None:
+        descCount   = descCount   + " (Samples)"
+        descMin     = descMin     + " (Min)"
+        descMax     = descMax     + " (Max)"
+        descAverage = descAverage + " (Average)"
+      self.genSchemaTextMap (stream, self.name + "Samples", descCount)
+      self.genSchemaTextMap (stream, self.name + "Min",     descMin)
+      self.genSchemaTextMap (stream, self.name + "Max",     descMax)
+      self.genSchemaTextMap (stream, self.name + "Average", descAverage)
+
+  def genAssign (self, stream):
+    if self.assign != None:
+      if self.type.type.perThread:
+        prefix = "    threadStats->"
+      else:
+        prefix = ""
+      stream.write ("    " + prefix + self.name + " = (" + self.type.type.cpp +
+                    ") (" + self.assign + ");\n")
+
+  def genWrite (self, stream):
+    if self.type.type.perThread:
+      self.type.type.genWrite (stream, "totals." + self.name)
+    else:
+      self.type.type.genWrite (stream, self.name)
+
+  def genMap (self, stream):
+    if self.type.type.perThread:
+      self.type.type.genMap(stream, "totals." + self.name, key=self.name)
+    else:
+      self.type.type.genMap(stream, self.name)
+
+  def genInitialize (self, stream, prefix="", indent="    "):
+    val = self.type.type.init
+    if self.type.type.style != "mma":
+      stream.write (indent + prefix + self.name + " = " + val + ";\n")
+    if self.type.type.style == "wm":
+      stream.write (indent + prefix + self.name + "High = " + val + ";\n")
+      stream.write (indent + prefix + self.name + "Low  = " + val + ";\n")
+    if self.type.type.style == "mma":
+      stream.write (indent + prefix + self.name + "Count = 0;\n")
+      stream.write (indent + prefix + self.name + "Min   = std::numeric_limits<" + self.type.type.cpp + ">::max();\n")
+      stream.write (indent + prefix + self.name + "Max   = std::numeric_limits<" + self.type.type.cpp + ">::min();\n")
+      stream.write (indent + prefix + self.name + "Total = 0;\n")
+
+  def genInitializeTotalPerThreadStats (self, stream):
+    if self.type.type.style == "mma":
+      stream.write ("    totals->" + self.name + "Count = 0;\n")
+      stream.write ("    totals->" + self.name + "Min   = std::numeric_limits<" + self.type.type.cpp + ">::max();\n")
+      stream.write ("    totals->" + self.name + "Max   = std::numeric_limits<" + self.type.type.cpp + ">::min();\n")
+      stream.write ("    totals->" + self.name + "Total = 0;\n")
+    else:
+      stream.write ("    totals->" + self.name + " = 0;\n")
+
+  def genAggregatePerThreadStats (self, stream):
+    if self.type.type.style == "mma":
+      stream.write ("            totals->%sCount += threadStats->%sCount;\n" % (self.name, self.name))
+      stream.write ("            if (totals->%sMin > threadStats->%sMin)\n" % (self.name, self.name))
+      stream.write ("                totals->%sMin = threadStats->%sMin;\n" % (self.name, self.name))
+      stream.write ("            if (totals->%sMax < threadStats->%sMax)\n" % (self.name, self.name))
+      stream.write ("                totals->%sMax = threadStats->%sMax;\n" % (self.name, self.name))
+      stream.write ("            totals->%sTotal += threadStats->%sTotal;\n" % (self.name, self.name))
+    else:
+      stream.write ("            totals->%s += threadStats->%s;\n" % (self.name, self.name))
+
+#=====================================================================================
+#
+#=====================================================================================
+class SchemaArg:
+  def __init__ (self, node, typespec):
+    self.name    = None
+    self.type    = None
+    self.unit    = None
+    self.dir     = "I"
+    self.min     = None
+    self.max     = None
+    self.maxLen  = None
+    self.desc    = None
+    self.default = None
+    self.hash    = Hash(node)
+
+    attrs = node.attributes
+    for idx in range (attrs.length):
+      key = attrs.item(idx).nodeName
+      val = attrs.item(idx).nodeValue
+      if   key == 'name':
+        self.name = makeValidCppSymbol(val)
+
+      elif key == 'type':
+        self.type = Type (val, typespec)
+        
+      elif key == 'unit':
+        self.unit = val
+
+      elif key == 'dir':
+        self.dir = val.upper ()
+        
+      elif key == 'min':
+        self.min = val
+        
+      elif key == 'max':
+        self.max = val
+        
+      elif key == 'maxlen':
+        self.maxLen = val
+        
+      elif key == 'desc':
+        self.desc = val
+
+      elif key == 'default':
+        self.default = val
+        
+      else:
+        raise ValueError ("Unknown attribute in arg '%s'" % key)
+
+    if self.name == None:
+      raise ValueError ("Missing 'name' attribute in arg")
+    if self.type == None:
+      raise ValueError ("Missing 'type' attribute in arg")
+
+  def getName (self):
+    return self.name
+
+  def getDir (self):
+    return self.dir
+
+  def genSchema (self, stream, event=False):
+    stream.write ("    ft.clear();\n")
+    stream.write ("    ft[NAME] = \"" + self.name + "\";\n")
+    stream.write ("    ft[TYPE] = TYPE_" + self.type.type.base +";\n")
+    if (not event):
+      stream.write ("    ft[DIR] = \"" + self.dir + "\";\n")
+    if self.unit != None:
+      stream.write ("    ft[UNIT] = \"" + self.unit + "\";\n")
+    if not event:
+      if self.min != None:
+        stream.write ("    ft[MIN] = " + self.min + ";\n")
+      if self.max != None:
+        stream.write ("    ft[MAX] = " + self.max + ";\n")
+      if self.maxLen != None:
+        stream.write ("    ft[MAXLEN] = " + self.maxLen + ";\n")
+      if self.default != None:
+        stream.write ("    ft[DEFAULT] = \"" + self.default + "\";\n")
+    if self.desc != None:
+      stream.write ("    ft[DESC] = \"" + self.desc + "\";\n")
+    stream.write ("    buf.putMap(ft);\n\n")
+
+  def genSchemaMap (self, stream, event=False):
+    stream.write ("        {\n")
+    stream.write ("            ::qpid::types::Variant::Map _avalue;\n")
+    stream.write ("            _avalue[TYPE] = TYPE_" + self.type.type.base +";\n")
+    if (not event):
+      stream.write ("            _avalue[DIR] = \"" + self.dir + "\";\n")
+    if self.unit != None:
+      stream.write ("            _avalue[UNIT] = \"" + self.unit + "\";\n")
+    if not event:
+      if self.min != None:
+        stream.write ("            _avalue[MIN] = " + self.min + ";\n")
+      if self.max != None:
+        stream.write ("            _avalue[MAX] = " + self.max + ";\n")
+      if self.maxLen != None:
+        stream.write ("            _avalue[MAXLEN] = " + self.maxLen + ";\n")
+      if self.default != None:
+        stream.write ("            _avalue[DEFAULT] = \"" + self.default + "\";\n")
+    if self.desc != None:
+      stream.write ("            _avalue[DESC] = \"" + self.desc + "\";\n")
+    stream.write ("            _args[\"" + self.name + "\"] = _avalue;\n")
+    stream.write ("        }\n")
+
+
+
+  def genFormalParam (self, stream, variables):
+    stream.write ("%s _%s" % (self.type.type.asArg, self.name))
+
+#=====================================================================================
+#
+#=====================================================================================
+class SchemaMethod:
+  def __init__ (self, parent, node, typespec):
+    self.parent = parent
+    self.name   = None
+    self.desc   = None
+    self.args   = []
+
+    attrs = node.attributes
+    for idx in range (attrs.length):
+      key = attrs.item(idx).nodeName
+      val = attrs.item(idx).nodeValue
+      if   key == 'name':
+        self.name = makeValidCppSymbol(val)
+
+      elif key == 'desc':
+        self.desc = val
+
+      else:
+        raise ValueError ("Unknown attribute in method '%s'" % key)
+
+    for child in node.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        if child.nodeName == 'arg':
+          arg = SchemaArg (child, typespec)
+          self.args.append (arg)
+        else:
+          raise ValueError ("Unknown method tag '%s'" % child.nodeName)
+
+  def getName (self):
+    return self.name
+
+  def getFullName (self):
+    return capitalize(self.parent.getName()) + self.name[0:1].upper() +\
+           self.name[1:]
+
+  def getArgCount (self):
+    return len (self.args)
+
+  #===================================================================================
+  # Code Generation Functions.  The names of these functions (minus the leading "gen")
+  # match the substitution keywords in the template files.
+  #===================================================================================
+  def genNameUpper (self, stream, variables):
+    stream.write (self.getFullName ().upper ())
+
+  def genNameCamel (self, stream, variables):
+    stream.write (self.getFullName ())
+
+  def genOpenNamespaces (self, stream, variables):
+    self.parent.genOpenNamespaces(stream, variables)
+
+  def genCloseNamespaces (self, stream, variables):
+    self.parent.genCloseNamespaces(stream, variables)
+
+  def genArguments (self, stream, variables):
+    for arg in self.args:
+      ctype  = arg.type.type.cpp
+      dirTag = arg.dir.lower() + "_"
+      stream.write ("    " + ctype + " " + dirTag + arg.getName () + ";\n")
+
+  def genNamePackageLower (self, stream, variables):
+    self.parent.genNamePackageLower(stream, variables)
+
+  def genSchema (self, stream, variables):
+    stream.write ("    ft.clear();\n")
+    stream.write ("    ft[NAME] =  \"" + self.name + "\";\n")
+    stream.write ("    ft[ARGCOUNT] = " + str (len (self.args)) + ";\n")
+    if self.desc != None:
+      stream.write ("    ft[DESC] = \"" + self.desc + "\";\n")
+    stream.write ("    buf.putMap(ft);\n\n")
+    for arg in self.args:
+      arg.genSchema (stream)
+
+  def genSchemaMap (self, stream, variables):
+    stream.write ("    {\n")
+    stream.write ("        ::qpid::types::Variant::Map _value;\n")
+    stream.write ("        ::qpid::types::Variant::Map _args;\n")
+    stream.write ("        _value[ARGCOUNT] = " + str(len(self.args)) + ";\n")
+    if self.desc != None:
+      stream.write ("        _value[DESC] = \"" + self.desc + "\";\n")
+
+    for arg in self.args:
+      arg.genSchemaMap (stream)
+
+    stream.write ("        if (!_args.empty())\n")
+    stream.write ("            _value[ARGS] = _args;\n")
+
+
+    stream.write ("        _methods[\"" + self.name + "\"] = _value;\n")
+    stream.write ("    }\n\n")
+
+#=====================================================================================
+#
+#=====================================================================================
+class SchemaEvent:
+  def __init__ (self, package, node, typespec, argset):
+    self.packageName = package
+    self.name = None
+    self.desc = None
+    self.sevText = "inform"
+    self.args = []
+    self.hash = Hash(node)
+
+    attrs = node.attributes
+    for idx in range (attrs.length):
+      key = attrs.item(idx).nodeName
+      val = attrs.item(idx).nodeValue
+      if   key == 'name':
+        self.name = val
+
+      elif key == 'desc':
+        self.desc = val
+
+      elif key == 'sev':
+        self.sevText = val
+
+      elif key == 'args':
+        list = val.replace(" ", "").split(",")
+        for item in list:
+          if item not in argset.args:
+            raise Exception("undefined argument '%s' in event" % item)
+          self.args.append(argset.args[item])
+          self.hash.addSubHash(argset.args[item].hash)
+
+      else:
+        raise ValueError ("Unknown attribute in event '%s'" % key)
+
+    if   self.sevText == "emerg"  : self.sev = 0
+    elif self.sevText == "alert"  : self.sev = 1
+    elif self.sevText == "crit"   : self.sev = 2
+    elif self.sevText == "error"  : self.sev = 3
+    elif self.sevText == "warn"   : self.sev = 4
+    elif self.sevText == "notice" : self.sev = 5
+    elif self.sevText == "inform" : self.sev = 6
+    elif self.sevText == "debug"  : self.sev = 7
+    else:
+      raise ValueError("Unknown severity '%s' in event '%s'" % (self.sevText, self.name))
+
+  def getName (self):
+    return self.name
+
+  def getNameCap(self):
+    return capitalize(self.name)
+
+  def getFullName (self):
+    return capitalize(self.package + capitalize(self.name))
+
+  def genAgentHeaderLocation (self, stream, variables):
+    stream.write(variables["agentHeaderDir"])
+
+  def getArgCount (self):
+    return len (self.args)
+
+  def genArgCount (self, stream, variables):
+    stream.write("%d" % len(self.args))
+
+  def genArgDeclarations(self, stream, variables):
+    for arg in self.args:
+      if arg.type.type.byRef:
+        ref = "&"
+      else:
+        ref = ""
+      stream.write("    const %s%s %s;\n" % (arg.type.type.cpp, ref, arg.name))
+
+  def genCloseNamespaces (self, stream, variables):
+    for item in self.packageName.split("."):
+      stream.write ("}")
+
+  def genConstructorArgs(self, stream, variables):
+    pre = ""
+    for arg in self.args:
+      if arg.type.type.byRef:
+        ref = "&"
+      else:
+        ref = ""
+      stream.write("%sconst %s%s _%s" % (pre, arg.type.type.cpp, ref, arg.name))
+      pre = ",\n        "
+
+  def genConstructorInits(self, stream, variables):
+    pre = ""
+    for arg in self.args:
+      stream.write("%s%s(_%s)" % (pre, arg.name, arg.name))
+      pre = ",\n    "
+
+  def genName(self, stream, variables):
+    stream.write(self.name)
+
+  def genNameCap(self, stream, variables):
+    stream.write(capitalize(self.name))
+
+  def genNamespace (self, stream, variables):
+    stream.write("::".join(self.packageName.split(".")))
+
+  def genNameLower(self, stream, variables):
+    stream.write(self.name.lower())
+
+  def genNameUpper(self, stream, variables):
+    stream.write(self.name.upper())
+
+  def genNamePackageLower(self, stream, variables):
+    stream.write(self.packageName.lower())
+
+  def genOpenNamespaces (self, stream, variables):
+    for item in self.packageName.split("."):
+      stream.write ("namespace %s {\n" % item)
+
+  def genSeverity(self, stream, variables):
+    stream.write("%d" % self.sev)
+
+  def genArgEncodes(self, stream, variables):
+    for arg in self.args:
+      stream.write("    " + arg.type.type.encode.replace("@", "buf").replace("#", arg.name) + ";\n")
+
+  def genArgMap(self, stream, variables):
+      for arg in self.args:
+          arg.type.type.genMap(stream, arg.name, "    ", mapName="map")
+      #stream.write("    " + arg.type.type.encode.replace("@", "buf").replace("#", arg.name) + ";\n")
+
+
+  def genArgSchema(self, stream, variables):
+    for arg in self.args:
+      arg.genSchema(stream, True)
+
+  def genArgSchemaMap(self, stream, variables):
+    for arg in self.args:
+      arg.genSchemaMap(stream, True)
+
+  def genSchemaMD5(self, stream, variables):
+    sum = self.hash.getDigest()
+    for idx in range (len (sum)):
+      if idx != 0:
+        stream.write (",")
+      stream.write (hex (ord (sum[idx])))
+
+
+class SchemaClass:
+  def __init__ (self, package, node, typespec, fragments, options):
+    self.packageName = package
+    self.properties  = []
+    self.statistics  = []
+    self.methods     = []
+    self.events      = []
+    self.options     = options
+    self.hash        = Hash(node)
+
+    attrs = node.attributes
+    self.name = makeValidCppSymbol(attrs['name'].nodeValue)
+
+    children = node.childNodes
+    for child in children:
+      if child.nodeType == Node.ELEMENT_NODE:
+        if   child.nodeName == 'property':
+          sub = SchemaProperty (child, typespec)
+          self.properties.append (sub)
+
+        elif child.nodeName == 'statistic':
+          sub = SchemaStatistic (child, typespec)
+          self.statistics.append (sub)
+
+        elif child.nodeName == 'method':
+          sub = SchemaMethod (self, child, typespec)
+          self.methods.append (sub)
+
+        elif child.nodeName == 'group':
+          self.expandFragment (child, fragments)
+
+        else:
+          raise ValueError ("Unknown class tag '%s'" % child.nodeName)
+
+    # Adjust the 'assign' attributes for each statistic
+    for stat in self.statistics:
+      if stat.assign != None and stat.type.type.perThread:
+        stat.assign = self.adjust (stat.assign, self.statistics)
+
+  def adjust (self, text, statistics):
+    result = text
+    start  = 0
+    while True:
+      next = None
+      for stat in statistics:
+        pos = result.find (stat.name, start)
+        if pos != -1 and (next == None or pos < next[0]):
+          next = (pos, stat.name)
+      if next == None:
+        return result
+      pos = next[0]
+      result = result[0:pos] + "threadStats->" + result[pos:]
+      start = pos + 9 + len(next[1])
+
+  def expandFragment (self, node, fragments):
+    attrs = node.attributes
+    name  = attrs['name'].nodeValue
+    for fragment in fragments:
+      if fragment.name == name:
+        self.hash.addSubHash(fragment.hash)
+        for config in fragment.properties:
+          self.properties.append (config)
+        for inst   in fragment.statistics:
+          self.statistics.append (inst)
+        for method in fragment.methods:
+          self.methods.append (method)
+        for event  in fragment.events:
+          self.events.append (event)
+        return
+    raise ValueError ("Undefined group '%s'" % name)
+
+  def getName (self):
+    return self.name
+
+  def getNameCap (self):
+    return capitalize(self.name)
+
+  def getMethods (self):
+    return self.methods
+
+  def getEvents (self):
+    return self.events
+
+  def getPackageNameCap (self):
+    return capitalize(self.packageName)
+
+  #===================================================================================
+  # Code Generation Functions.  The names of these functions (minus the leading "gen")
+  # match the substitution keywords in the template files.
+  #===================================================================================
+  def testExistOptionals (self, variables):
+    for prop in self.properties:
+      if prop.isOptional == 1:
+        return True
+    return False
+
+  def testExistPerThreadStats (self, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread:
+        return True
+    return False
+
+  def testExistPerThreadAssign (self, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread and inst.assign != None:
+        return True
+    return False
+
+  def testExistPerThreadResets (self, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread and inst.type.type.style == "mma":
+        return True
+    return False
+
+  def testNoStatistics (self, variables):
+    return len (self.statistics) == 0
+
+  def genAccessorMethods (self, stream, variables):
+    for config in self.properties:
+      if config.access != "RC":
+        config.genAccessor (stream)
+    for inst in self.statistics:
+      if inst.assign == None:
+        inst.genAccessor (stream)
+
+  def genAgentHeaderLocation (self, stream, variables):
+    stream.write(variables["agentHeaderDir"])
+
+  def genCloseNamespaces (self, stream, variables):
+    for item in self.packageName.split("."):
+      stream.write ("}")
+
+  def genConfigCount (self, stream, variables):
+    stream.write ("%d" % len (self.properties))
+
+  def genConfigDeclarations (self, stream, variables):
+    for element in self.properties:
+      element.genDeclaration (stream)
+
+  def genConstructorArgs (self, stream, variables):
+    # Constructor args are config elements with read-create access
+    result = ""
+    for element in self.properties:
+      if element.isConstructorArg ():
+        stream.write (", ")
+        element.genFormalParam (stream, variables)
+
+  def genConstructorInits (self, stream, variables):
+    for element in self.properties:
+      if element.isConstructorArg ():
+        stream.write ("," + element.getName () + "(_" + element.getName () + ")")
+
+  def genDoMethodArgs (self, stream, variables):
+    methodCount = 0
+    inArgCount  = 0
+    for method in self.methods:
+      methodCount = methodCount + 1
+      for arg in method.args:
+        if arg.getDir () == "I" or arg.getDir () == "IO":
+          inArgCount = inArgCount + 1
+
+    if methodCount == 0:
+      stream.write ("string&, const string&, string& outStr, const string&")
+    else:
+      if inArgCount == 0:
+        stream.write ("string& methodName, const string&, string& outStr, const string& userId")
+      else:
+        stream.write ("string& methodName, const string& inStr, string& outStr, const string& userId")
+
+
+  def genDoMapMethodArgs (self, stream, variables):
+    methodCount = 0
+    inArgCount  = 0
+    for method in self.methods:
+      methodCount = methodCount + 1
+      for arg in method.args:
+        if arg.getDir () == "I" or arg.getDir () == "IO":
+          inArgCount = inArgCount + 1
+
+    if methodCount == 0:
+      stream.write ("string&," +
+                    " const ::qpid::types::Variant::Map&," +
+                    " ::qpid::types::Variant::Map& outMap, const string&")
+    else:
+      if inArgCount == 0:
+        stream.write ("string& methodName," +
+                      " const ::qpid::types::Variant::Map&," +
+                      " ::qpid::types::Variant::Map& outMap, const string& userId")
+      else:
+        stream.write ("string& methodName," +
+                      " const ::qpid::types::Variant::Map& inMap," +
+                      " ::qpid::types::Variant::Map& outMap, const string& userId")
+
+  def genHiLoStatResets (self, stream, variables):
+    for inst in self.statistics:
+      if not inst.type.type.perThread:
+        inst.genHiLoStatResets (stream)
+
+  def genPerThreadHiLoStatResets (self, stream, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread:
+        inst.genPerThreadHiLoStatResets (stream)
+
+  def genInitializeElements (self, stream, variables):
+    for prop in self.properties:
+      if not prop.isConstructorArg() and not prop.isParentRef:
+        prop.genInitialize(stream)
+    for inst in self.statistics:
+      if not inst.type.type.perThread:
+        inst.genInitialize (stream)
+
+  def genInitializePerThreadElements (self, stream, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread:
+        inst.genInitialize (stream, "threadStats->", "            ")
+
+  def genInitializeTotalPerThreadStats (self, stream, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread:
+        inst.genInitializeTotalPerThreadStats (stream)
+
+  def genAggregatePerThreadStats (self, stream, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread:
+        inst.genAggregatePerThreadStats (stream)
+
+  def genInstCount (self, stream, variables):
+    count = 0
+    for inst in self.statistics:
+      count = count + 1
+      if inst.type.type.style == "wm":
+        count = count + 2
+      if inst.type.type.style == "mma":
+        count = count + 3
+    stream.write ("%d" % count)
+
+  def genInstDeclarations (self, stream, variables):
+    for element in self.statistics:
+      if not element.type.type.perThread:
+        element.genDeclaration (stream)
+
+  def genPerThreadDeclarations (self, stream, variables):
+    for element in self.statistics:
+      if element.type.type.perThread:
+        element.genDeclaration (stream, "        ")
+
+  def genPrimaryKey (self, stream, variables):
+    first = 1
+    for prop in self.properties:
+      # deliberately leave out the "vhostRef" fields since there's only one vhost,
+      # this serves to shorten the keys without compromising uniqueness
+      if prop.getName() != "vhostRef":
+        if prop.isIndex == 1:
+          if first:
+            first = None
+          else:
+            stream.write(" << \",\";\n")
+          var = prop.type.type.stream.replace("#", prop.getName())
+          stream.write("    key << %s" % var)
+    if not first:
+      stream.write(";")
+
+  def genNamespace (self, stream, variables):
+    stream.write("::".join(self.packageName.split(".")))
+
+  def genMethodArgIncludes (self, stream, variables):
+    for method in self.methods:
+      if method.getArgCount () > 0:
+        stream.write ("#include \"Args" + method.getFullName () + ".h\"\n")
+
+  def genMethodCount (self, stream, variables):
+    stream.write ("%d" % len (self.methods))
+
+  def genMethodHandlers (self, stream, variables):
+    inArgs = False
+    for method in self.methods:
+      for arg in method.args:
+        if arg.getDir () == "I" or arg.getDir () == "IO":
+            inArgs = True;
+            break
+
+    if inArgs:
+        stream.write("\n")
+        stream.write("    char *_tmpBuf = new char[inStr.length()];\n")
+        stream.write("    memcpy(_tmpBuf, inStr.data(), inStr.length());\n")
+        stream.write("    ::qpid::management::Buffer inBuf(_tmpBuf, inStr.length());\n")
+
+    for method in self.methods:
+      stream.write ("\n    if (methodName == \"" + method.getName () + "\") {\n")
+      stream.write ("        _matched = true;\n")
+      if method.getArgCount () == 0:
+        stream.write ("        ::qpid::management::ArgsNone ioArgs;\n")
+      else:
+        stream.write ("        Args" + method.getFullName () + " ioArgs;\n")
+      for arg in method.args:
+        if arg.getDir () == "I" or arg.getDir () == "IO":
+          stream.write ("        " +\
+                        arg.type.type.getReadCode ("ioArgs." +\
+                                                   arg.dir.lower () + "_" +\
+                                                   arg.name, "inBuf") + ";\n")
+
+      stream.write ("        bool allow = coreObject->AuthorizeMethod(METHOD_" +\
+                    method.getName().upper() + ", ioArgs, userId);\n")
+      stream.write ("        if (allow)\n")
+      stream.write ("            status = coreObject->ManagementMethod (METHOD_" +\
+                    method.getName().upper() + ", ioArgs, text);\n")
+      stream.write ("        else\n")
+      stream.write ("            status = Manageable::STATUS_FORBIDDEN;\n")
+      stream.write ("        outBuf.putLong        (status);\n")
+      stream.write ("        outBuf.putMediumString(::qpid::management::Manageable::StatusText (status, text));\n")
+      for arg in method.args:
+        if arg.getDir () == "O" or arg.getDir () == "IO":
+          stream.write ("        " +\
+                        arg.type.type.getWriteCode ("ioArgs." +\
+                                                    arg.dir.lower () + "_" +\
+                                                        arg.name, "outBuf") + ";\n")
+      stream.write("    }\n")
+
+    if inArgs:
+        stream.write ("\n    delete [] _tmpBuf;\n")
+
+
+
+  def genMapMethodHandlers (self, stream, variables):
+    for method in self.methods:
+      stream.write ("\n    if (methodName == \"" + method.getName () + "\") {\n")
+      if method.getArgCount () == 0:
+        stream.write ("        ::qpid::management::ArgsNone ioArgs;\n")
+      else:
+        stream.write ("        Args" + method.getFullName () + " ioArgs;\n")
+        stream.write ("        ::qpid::types::Variant::Map::const_iterator _i;\n")
+
+      # decode each input argument from the input map
+      for arg in method.args:
+        if arg.getDir () == "I" or arg.getDir () == "IO":
+          arg.type.type.genUnmap(stream,
+                                 "ioArgs." + arg.dir.lower () + "_" + arg.name,
+                                 "        ",
+                                 arg.name,
+                                 "inMap")
+
+      stream.write ("        bool allow = coreObject->AuthorizeMethod(METHOD_" +\
+                    method.getName().upper() + ", ioArgs, userId);\n")
+      stream.write ("        if (allow)\n")
+      stream.write ("            status = coreObject->ManagementMethod (METHOD_" +\
+                    method.getName().upper() + ", ioArgs, text);\n")
+      stream.write ("        else\n")
+      stream.write ("            status = Manageable::STATUS_FORBIDDEN;\n")
+      stream.write ("        outMap[\"_status_code\"] = (uint32_t) status;\n")
+      stream.write ("        outMap[\"_status_text\"] = ::qpid::management::Manageable::StatusText(status, text);\n")
+      for arg in method.args:
+        if arg.getDir () == "O" or arg.getDir () == "IO":
+          arg.type.type.genMap(stream,
+                                 "ioArgs." + arg.dir.lower () + "_" + arg.name,
+                                 "        ",
+                                 arg.name,
+                                 "outMap")
+      stream.write ("        return;\n    }\n")
+
+  def genOpenNamespaces (self, stream, variables):
+    for item in self.packageName.split("."):
+      stream.write ("namespace %s {\n" % item)
+
+  def genPresenceMaskBytes (self, stream, variables):
+    count = 0
+    for prop in self.properties:
+      if prop.isOptional == 1:
+        count += 1
+    if count == 0:
+      stream.write("0")
+    else:
+      stream.write (str(((count - 1) / 8) + 1))
+
+  def genPresenceMaskConstants (self, stream, variables):
+    count = 0
+    for prop in self.properties:
+      if prop.isOptional == 1:
+        stream.write("    static const uint8_t presenceByte_%s = %d;\n" % (prop.name, count / 8))
+        stream.write("    static const uint8_t presenceMask_%s = %d;\n" % (prop.name, 1 << (count % 8)))
+        count += 1
+
+  def genPropertySchema (self, stream, variables):
+    for prop in self.properties:
+      prop.genSchema (stream)
+
+  def genPropertySchemaMap (self, stream, variables):
+    for prop in self.properties:
+      prop.genSchemaMap(stream)
+
+  def genSetGeneralReferenceDeclaration (self, stream, variables):
+    for prop in self.properties:
+      if prop.isGeneralRef:
+        stream.write ("void setReference(::qpid::management::ObjectId objectId) { " + prop.name + " = objectId; }\n")
+
+  def genStatisticSchema (self, stream, variables):
+    for stat in self.statistics:
+      stat.genSchema (stream)
+
+  def genStatisticSchemaMap (self, stream, variables):
+    for stat in self.statistics:
+      stat.genSchemaMap(stream)
+
+  def genMethodIdDeclarations (self, stream, variables):
+    number = 1
+    for method in self.methods:
+      stream.write ("    static const uint32_t METHOD_" + method.getName().upper() +\
+                    " = %d;\n" % number)
+      number = number + 1
+
+  def genMethodSchema (self, stream, variables):
+    for method in self.methods:
+      method.genSchema (stream, variables)
+
+  def genMethodSchemaMap(self, stream, variables):
+    for method in self.methods:
+      method.genSchemaMap(stream, variables)
+
+  def genName (self, stream, variables):
+    stream.write (self.name)
+
+  def genNameCap (self, stream, variables):
+    stream.write (capitalize(self.name))
+
+  def genNameLower (self, stream, variables):
+    stream.write (self.name.lower ())
+
+  def genNamePackageCap (self, stream, variables):
+    stream.write (self.getPackageNameCap ())
+
+  def genNamePackageLower (self, stream, variables):
+    stream.write (self.packageName.lower ())
+
+  def genNameUpper (self, stream, variables):
+    stream.write (self.name.upper ())
+
+  def genParentArg (self, stream, variables):
+    for config in self.properties:
+      if config.isParentRef == 1:
+        stream.write (", ::qpid::management::Manageable* _parent")
+        return
+
+  def genParentRefAssignment (self, stream, variables):
+    for config in self.properties:
+      if config.isParentRef == 1:
+        stream.write (config.getName () + \
+                      " = _parent->GetManagementObject ()->getObjectId ();")
+        return
+
+  def genSchemaMD5 (self, stream, variables):
+    sum = self.hash.getDigest()
+    for idx in range (len (sum)):
+      if idx != 0:
+        stream.write (",")
+      stream.write (hex (ord (sum[idx])))
+
+  def genAssign (self, stream, variables):
+    for inst in self.statistics:
+      if not inst.type.type.perThread:
+        inst.genAssign (stream)
+
+  def genPerThreadAssign (self, stream, variables):
+    for inst in self.statistics:
+      if inst.type.type.perThread:
+        inst.genAssign (stream)
+
+  def genSizeProperties (self, stream, variables):
+    for prop in self.properties:
+      prop.genSize (stream)
+
+  def genReadProperties (self, stream, variables):
+    for prop in self.properties:
+      prop.genRead (stream)
+
+  def genWriteProperties (self, stream, variables):
+    for prop in self.properties:
+      prop.genWrite (stream)
+
+  def genWriteStatistics (self, stream, variables):
+    for stat in self.statistics:
+      stat.genWrite (stream)
+
+  def genMapEncodeProperties(self, stream, variables):
+      for prop in self.properties:
+          prop.genMap (stream)
+
+  def genMapEncodeStatistics (self, stream, variables):
+      for stat in self.statistics:
+          stat.genMap (stream)
+
+  def genMapDecodeProperties (self, stream, variables):
+      for prop in self.properties:
+          prop.genUnmap (stream)
+
+class SchemaEventArgs:
+  def __init__(self, package, node, typespec, fragments, options):
+    self.packageName = package
+    self.options     = options
+    self.args        = {}
+
+    children = node.childNodes
+    for child in children:
+      if child.nodeType == Node.ELEMENT_NODE:
+        if child.nodeName == 'arg':
+          arg = SchemaArg(child, typespec)
+          self.args[arg.name] = arg
+        else:
+          raise Exception("Unknown tag '%s' in <eventArguments>" % child.nodeName)
+
+class SchemaPackage:
+  def __init__ (self, typefile, schemafile, options):
+
+    self.classes   = []
+    self.fragments = []
+    self.typespec  = TypeSpec (typefile)
+    self.eventArgSet = None
+    self.events    = []
+
+    dom = parse (schemafile)
+    document = dom.documentElement
+    if document.tagName != 'schema':
+      raise ValueError ("Expected 'schema' node")
+    attrs = document.attributes
+    pname = attrs['package'].nodeValue
+    namelist = pname.split('.')
+    self.packageName = ".".join(namelist)
+
+    children = document.childNodes
+    for child in children:
+      if child.nodeType == Node.ELEMENT_NODE:
+        if child.nodeName == 'class':
+          cls = SchemaClass (self.packageName, child, self.typespec,
+                             self.fragments, options)
+          self.classes.append (cls)
+
+        elif child.nodeName == 'group':
+          cls = SchemaClass (self.packageName, child, self.typespec,
+                             self.fragments, options)
+          self.fragments.append (cls)
+
+        elif child.nodeName == 'eventArguments':
+          if self.eventArgSet:
+            raise Exception("Only one <eventArguments> may appear in a package")
+          self.eventArgSet = SchemaEventArgs(self.packageName, child, self.typespec, self.fragments, options)
+
+        elif child.nodeName == 'event':
+          event = SchemaEvent(self.packageName, child, self.typespec, self.eventArgSet)
+          self.events.append(event)
+
+        else:
+          raise ValueError ("Unknown schema tag '%s'" % child.nodeName)
+
+  def getPackageName (self):
+    return self.packageName
+
+  def getPackageNameCap (self):
+    return capitalize(self.packageName)
+
+  def getPackageNameLower (self):
+    return self.packageName.lower()
+
+  def getClasses (self):
+    return self.classes
+
+  def getEvents(self):
+    return self.events
+
+  def genAgentHeaderLocation (self, stream, variables):
+    stream.write(variables["agentHeaderDir"])
+
+  def genCloseNamespaces (self, stream, variables):
+    for item in self.packageName.split("."):
+      stream.write ("}")
+
+  def genNamespace (self, stream, variables):
+    stream.write("::".join(self.packageName.split(".")))
+
+  def genOpenNamespaces (self, stream, variables):
+    for item in self.packageName.split("."):
+      stream.write ("namespace %s {\n" % item)
+
+  def genPackageNameUpper (self, stream, variables):
+    up = "_".join(self.packageName.split("."))
+    stream.write (up.upper())
+
+  def genPackageName (self, stream, variables):
+    stream.write(self.packageName)
+
+  def genNamePackageLower (self, stream, variables):
+    stream.write (self.packageName.lower ())
+
+  def genClassIncludes (self, stream, variables):
+    for _class in self.classes:
+      stream.write ("#include \"")
+      _class.genNameCap (stream, variables)
+      stream.write (".h\"\n")
+    for _event in self.events:
+      stream.write ("#include \"Event")
+      _event.genNameCap(stream, variables)
+      stream.write (".h\"\n")
+
+  def genClassRegisters(self, stream, variables):
+    for _class in self.classes:
+      stream.write("    ")
+      _class.genNameCap(stream, variables)
+      stream.write("::registerSelf(agent);\n")
+    for _event in self.events:
+      stream.write("    Event")
+      _event.genNameCap(stream, variables)
+      stream.write("::registerSelf(agent);\n")
+
+  def genV2ClassMembers(self, stream, variables):
+      for _class in self.classes:
+          stream.write("    ::qmf::Schema data_%s;\n" % _class.name)
+      for _event in self.events:
+          stream.write("    ::qmf::Schema event_%s;\n" % _event.name)
+
+  def genV2ClassDefines(self, stream, variables):
+      for _class in self.classes:
+          stream.write("\n    //\n    // Data: %s\n    //\n" % _class.name)
+          stream.write("    data_%s = qmf::Schema(SCHEMA_TYPE_DATA, package, \"%s\");\n" % (_class.name, _class.name))
+
+          for prop in _class.properties:
+              typeName, subType = self.qmfv2Type(prop.type)
+              access = self.qmfv2Access(prop.access)
+              stream.write("    {\n")
+              stream.write("        qmf::SchemaProperty prop(\"%s\", %s);\n" % (prop.name, typeName))
+              if subType:
+                  stream.write("        prop.setSubtype(\"%s\");\n" % subType)
+              stream.write("        prop.setAccess(%s);\n" % access)
+              if prop.isIndex == 1:
+                  stream.write("        prop.setIndex(true);\n")
+              if prop.isOptional == 1:
+                  stream.write("        prop.setOptional(true);\n")
+              if prop.unit:
+                  stream.write("        prop.setUnit(\"%s\");\n" % prop.unit)
+              if prop.desc:
+                  stream.write("        prop.setDesc(\"%s\");\n" % prop.desc)
+              stream.write("        data_%s.addProperty(prop);\n" % _class.name)
+              stream.write("    }\n\n")
+
+          for stat in _class.statistics:
+              typeName, subType = self.qmfv2Type(stat.type)
+              stream.write("    {\n")
+              stream.write("        qmf::SchemaProperty prop(\"%s\", %s);\n" % (stat.name, typeName))
+              if subType:
+                  stream.write("        prop.setSubtype(\"%s\");\n" % subType)
+              if stat.unit:
+                  stream.write("        prop.setUnit(\"%s\");\n" % stat.unit)
+              if stat.desc:
+                  stream.write("        prop.setDesc(\"%s\");\n" % stat.desc)
+              stream.write("        data_%s.addProperty(prop);\n" % _class.name)
+              stream.write("    }\n\n")
+
+          for method in _class.methods:
+              stream.write("    {\n")
+              stream.write("        qmf::SchemaMethod method(\"%s\");\n" % method.name)
+              if method.desc:
+                  stream.write("        method.setDesc(\"%s\");\n" % method.desc)
+                  
+              for arg in method.args:
+                  typeName, subType = self.qmfv2Type(arg.type)
+                  stream.write("        {\n")
+                  stream.write("            qmf::SchemaProperty arg(\"%s\", %s);\n" % (arg.name, typeName))
+                  if subType:
+                      stream.write("            arg.setSubtype(\"%s\");\n" % subType)
+                  if arg.unit:
+                      stream.write("            arg.setUnit(\"%s\");\n" % arg.unit)
+                  if arg.desc:
+                      stream.write("            arg.setDesc(\"%s\");\n" % arg.desc)
+                  stream.write("            arg.setDirection(%s);\n" % self.qmfv2Dir(arg.dir))
+                  stream.write("            method.addArgument(arg);\n")
+                  stream.write("        }\n\n")
+                  
+              stream.write("        data_%s.addMethod(method);\n" % _class.name)
+              stream.write("    }\n\n")
+
+          stream.write("    session.registerSchema(data_%s);\n" % _class.name)
+
+      for _event in self.events:
+          stream.write("\n    //\n    // Event: %s\n    //\n" % _event.name)
+          stream.write("    event_%s = qmf::Schema(SCHEMA_TYPE_EVENT, package, \"%s\");\n" % (_event.name, _event.name))
+          stream.write("    event_%s.setDefaultSeverity(%s);\n" % (_event.name, self.qmfv2Severity(_event.sev)))
+          for prop in _event.args:
+              typeName, subType = self.qmfv2Type(prop.type)
+              stream.write("    {\n")
+              stream.write("        qmf::SchemaProperty prop(\"%s\", %s);\n" % (prop.name, typeName))
+              if subType:
+                  stream.write("        prop.setSubtype(\"%s\");\n" % subType)
+              if prop.unit:
+                  stream.write("        prop.setUnit(\"%s\");\n" % prop.unit)
+              if prop.desc:
+                  stream.write("        prop.setDesc(\"%s\");\n" % prop.desc)
+              stream.write("        event_%s.addProperty(prop);\n" % _event.name)
+              stream.write("    }\n\n")
+
+          stream.write("    session.registerSchema(event_%s);\n" % _event.name)
+              
+
+  def qmfv2Type(self, typecode):
+      base = typecode.type.base
+      if base == "REF"       : return ("qmf::SCHEMA_DATA_MAP", "reference")
+      if base == "U8"        : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "U16"       : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "U32"       : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "U64"       : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "S8"        : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "S16"       : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "S32"       : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "S64"       : return ("qmf::SCHEMA_DATA_INT", None)
+      if base == "BOOL"      : return ("qmf::SCHEMA_DATA_BOOL", None)
+      if base == "SSTR"      : return ("qmf::SCHEMA_DATA_STRING", None)
+      if base == "LSTR"      : return ("qmf::SCHEMA_DATA_STRING", None)
+      if base == "ABSTIME"   : return ("qmf::SCHEMA_DATA_INT", "abstime")
+      if base == "DELTATIME" : return ("qmf::SCHEMA_DATA_INT", "deltatime")
+      if base == "FLOAT"     : return ("qmf::SCHEMA_DATA_FLOAT", None)
+      if base == "DOUBLE"    : return ("qmf::SCHEMA_DATA_FLOAT", None)
+      if base == "UUID"      : return ("qmf::SCHEMA_DATA_UUID", None)
+      if base == "FTABLE"    : return ("qmf::SCHEMA_DATA_MAP", None)
+      if base == "LIST"      : return ("qmf::SCHEMA_DATA_LIST", None)
+      raise ValueError("Unknown base type %s" % base)
+
+  def qmfv2Access(self, code):
+      if code == "RC": return "qmf::ACCESS_READ_CREATE"
+      if code == "RO": return "qmf::ACCESS_READ_ONLY"
+      if code == "RW": return "qmf::ACCESS_READ_WRITE"
+      raise ValueError("Unknown access type %s" % code)
+
+  def qmfv2Dir(self, code):
+      if code == "I" : return "qmf::DIR_IN"
+      if code == "O" : return "qmf::DIR_OUT"
+      if code == "IO": return "qmf::DIR_IN_OUT"
+      raise ValueError("Unknown direction type %s" % code)
+
+  def qmfv2Severity(self, code):
+      if code == 0 : return "qmf::SEV_EMERG"
+      if code == 1 : return "qmf::SEV_ALERT"
+      if code == 2 : return "qmf::SEV_CRIT"
+      if code == 3 : return "qmf::SEV_ERROR"
+      if code == 4 : return "qmf::SEV_WARN"
+      if code == 5 : return "qmf::SEV_NOTICE"
+      if code == 6 : return "qmf::SEV_INFORM"
+      if code == 7 : return "qmf::SEV_DEBUG"
+      raise ValueError("Out of Range Severity %d" % code)
+
+#=====================================================================================
+# Utility Functions
+#=====================================================================================
+
+# Create a valid C++ symbol from the input string so that it can be
+# used in generated C++ source. For instance, change "qpid.mgmt" to
+# "qpidMgmt".
+#
+# Input: Raw string (str) to process
+# Output: String (str) suitable for use as a C++ symbol
+#
+# Limitations: Currently, only strips periods ('.') from strings,
+#              eventually should strip :'s and ,'s and ''s, oh my!
+def makeValidCppSymbol(input):
+  output = str()
+  capitalize = False
+
+  for char in input:
+    skip = False
+
+    if char == ".":
+      capitalize = True
+      skip = True
+
+    if not skip:
+      output += capitalize and char.upper() or char
+
+      capitalize = False
+
+  return output
+
+# Capitalize a string by /only/ forcing the first character to be
+# uppercase. The rest of the string is left alone. This is different
+# from str.capitalize(), which forces the first character to uppercase
+# and the rest to lowercase.
+#
+# Input: A string (str) to capitalize
+# Output: A string (str) with the first character as uppercase
+def capitalize(input):
+  return input[0].upper() + input[1:]