docs: def _setAttributes(self, attributes):
          '''parameters
          attributes -- a flat list of all attributes, 
          from this list all items in attribute_typecode_dict will
          be generated into attrComponents.
          
          returns a list of strings representing the attribute_typecode_dict.
          '''
          atd = self.attribute_typecode
          atd_list = formatted_attribute_list = []
          if not attributes:
              return formatted_attribute_list
          
          atd_list.append('# attribute handling code')
          idx = 0
          while(idx < len(attributes)):
              a = attributes[idx] 
              idx += 1
              if a.isWildCard() and a.isDeclaration():
                  atd_list.append(\
                      '%s[("%s","anyAttribute")] = ZSI.TC.AnyElement()'\
                      % (atd, SCHEMA.XSD3)
                      )
              elif a.isDeclaration():
                  tdef = a.getTypeDefinition('type')
                  if tdef is not None:
                      tc = '%s.%s(None)' %(NAD.getAlias(tdef.getTargetNamespace()),
                          self.mangle(type_class_name(tdef.getAttributeName()))
                          )
                  else:
                      # built-in
                      t = a.getAttribute('type')
                      try:
                          tc = BTI.get_typeclass(t[1], t[0])
                      except:
                          # hand back a string by default.
                          tc = ZSI.TC.String
                              
                      if tc is not None: 
                          tc = '%s()' %tc
                              
                  key = None
                  if a.getAttribute('form') == 'qualified':
                      key = '("%s","%s")' % ( a.getTargetNamespace(),
                                              a.getAttribute('name') )
                  elif a.getAttribute('form') == 'unqualified':
                      key = '"%s"' % a.getAttribute('name')
                  else:
                      raise ContainerError, \
                            'attribute form must be un/qualified %s' \
                            % a.getAttribute('form')
                            
                  atd_list.append(\
                      '%s[%s] = %s' % (atd, key, tc)
                      )
              elif a.isReference() and a.isAttributeGroup():
                  # flatten 'em out....
                  for ga in a.getAttributeGroup().getAttributeContent():
                      attributes += (ga,)
  
              elif a.isReference():
                  try:
                      ga = a.getAttributeDeclaration()
                  except XMLSchema.SchemaError:
                      key = a.getAttribute('ref')
                      self.logger.debug('No schema item for attribute ref (%s, %s)' %key)
                      if key in self.built_in_refs: continue
                      raise
                          
                  tp = None
                  if ga is not None:
                      tp = ga.getTypeDefinition('type')           
                      key = '("%s","%s")' %(ga.getTargetNamespace(),
                               ga.getAttribute('name'))
                               
                  if ga is None:
                      # TODO: probably SOAPENC:arrayType
                      key = '("%s","%s")' %(
                               a.getAttribute('ref').getTargetNamespace(),
                               a.getAttribute('ref').getName())
                      atd_list.append(\
                          '%s[%s] = ZSI.TC.String()' %(atd, key)
                          )
                  elif tp is None:
                      # built in simple type
                      try:
                          namespace,typeName = ga.getAttribute('type')
                      except TypeError, ex:
                          # TODO: attribute declaration could be anonymous type
                          # hack in something to work
                          atd_list.append(\
                              '%s[%s] = ZSI.TC.String()' %(atd, key)
                              )
                      else:
                          atd_list.append(\
                              '%s[%s] = %s()' %(atd, key, 
                                   BTI.get_typeclass(typeName, namespace))
                              )
                  else:
                      typeName = tp.getAttribute('name')
                      namespace = tp.getTargetNamespace()
                      alias = NAD.getAlias(namespace)
                      key = '("%s","%s")' \
                            % (ga.getTargetNamespace(),ga.getAttribute('name'))
                      atd_list.append(\
                          '%s[%s] = %s.%s(None)' \
                          % (atd, key, alias, type_class_name(typeName))
                          )
              else:
                  raise TypeError, 'expecting an attribute: %s' %a.getItemTrace()
              
          return formatted_attribute_list