def parseSchema()

in qpid/management.py [0:0]
109 lines of code
3 McCabe index (conditional complexity)

  def parseSchema (self, ch, codec):
    """ Parse a received schema-description message. """
    self.decOutstanding (ch)
    kind  = codec.read_uint8()
    if kind != 1:  # This API doesn't handle new-style events
      return
    packageName = codec.read_str8 ()
    className   = codec.read_str8 ()
    hash        = codec.read_bin128 ()
    hasSupertype = 0 #codec.read_uint8()
    configCount = codec.read_uint16 ()
    instCount   = codec.read_uint16 ()
    methodCount = codec.read_uint16 ()
    if hasSupertype != 0:
      supertypePackage = codec.read_str8()
      supertypeClass   = codec.read_str8()
      supertypeHash    = codec.read_bin128()

    if packageName not in self.packages:
      return
    if (className, hash) in self.packages[packageName]:
      return

    classKey = (packageName, className, hash)
    if classKey in self.schema:
      return

    configs = []
    insts   = []
    methods = {}

    configs.append (("id", 4, "", "", 1, 1, None, None, None, None, None))
    insts.append   (("id", 4, None, None))

    for idx in range (configCount):
      ft = codec.read_map ()
      name     = str (ft["name"])
      type     = ft["type"]
      access   = ft["access"]
      index    = ft["index"]
      optional = ft["optional"]
      unit     = None
      min      = None
      max      = None
      maxlen   = None
      desc     = None

      for key, value in ft.items ():
        if   key == "unit":
          unit = str (value)
        elif key == "min":
          min = value
        elif key == "max":
          max = value
        elif key == "maxlen":
          maxlen = value
        elif key == "desc":
          desc = str (value)

      config = (name, type, unit, desc, access, index, min, max, maxlen, optional)
      configs.append (config)

    for idx in range (instCount):
      ft = codec.read_map ()
      name   = str (ft["name"])
      type   = ft["type"]
      unit   = None
      desc   = None

      for key, value in ft.items ():
        if   key == "unit":
          unit = str (value)
        elif key == "desc":
          desc = str (value)

      inst = (name, type, unit, desc)
      insts.append (inst)

    for idx in range (methodCount):
      ft = codec.read_map ()
      mname    = str (ft["name"])
      argCount = ft["argCount"]
      if "desc" in ft:
        mdesc = str (ft["desc"])
      else:
        mdesc = None

      args = []
      for aidx in range (argCount):
        ft = codec.read_map ()
        name    = str (ft["name"])
        type    = ft["type"]
        dir     = str (ft["dir"].upper ())
        unit    = None
        min     = None
        max     = None
        maxlen  = None
        desc    = None
        default = None

        for key, value in ft.items ():
          if   key == "unit":
            unit = str (value)
          elif key == "min":
            min = value
          elif key == "max":
            max = value
          elif key == "maxlen":
            maxlen = value
          elif key == "desc":
            desc = str (value)
          elif key == "default":
            default = str (value)

        arg = (name, type, dir, unit, desc, min, max, maxlen, default)
        args.append (arg)
      methods[mname] = (mdesc, args)

    schemaClass = {}
    schemaClass['C'] = configs
    schemaClass['I'] = insts
    schemaClass['M'] = methods
    self.schema[classKey] = schemaClass

    if self.schemaCb != None:
      self.schemaCb (ch.context, classKey, configs, insts, methods, {})