schema.cpp

linux下简单对象应用协议的开发库

  if (!simpleTypeRef)
  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
    { xs__schema *s = (*i).schemaPtr();
      if (s)
      { token = qname_token(base, s->targetNamespace);
        if (token)
        { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
            if (!strcmp((*j).name, token))
            { simpleTypeRef = &(*j);
              if (vflag)
                cerr << "Found restriction base type " << (token?token:"") << endl;
              break;
            }
          break;
        }
      }
    }
  }
  token = qname_token(base, schema.targetNamespace);
  complexTypeRef = NULL;
  if (token)
  { for (vector<xs__complexType>::iterator i = schema.complexType.begin(); i != schema.complexType.end(); ++i)
      if (!strcmp((*i).name, token))
      { complexTypeRef = &(*i);
        if (vflag)
          cerr << "Found restriction base type " << (token?token:"") << endl;
        break;
      }
  }
  if (!complexTypeRef)
  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
    { xs__schema *s = (*i).schemaPtr();
      if (s)
      { token = qname_token(base, s->targetNamespace);
        if (token)
        { for (vector<xs__complexType>::iterator j = s->complexType.begin(); j != s->complexType.end(); ++j)
            if (!strcmp((*j).name, token))
            { complexTypeRef = &(*j);
              if (vflag)
                cerr << "Found restriction base type " << (token?token:"") << endl;
              break;
            }
          break;
        }
      }
    }
  }
  if (!simpleTypeRef && !complexTypeRef)
  { if (base)
    { if (is_builtin_qname(base))
        schema.builtinType(base);
      else
        cerr << "Warning: could not find restriction base type '" << base << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
    }
    else
      cerr << "Restriction has no base" << endl;
  }
  return SOAP_OK;
}

void xs__restriction::simpleTypePtr(xs__simpleType *simpleType)
{ simpleTypeRef = simpleType;
}

void xs__restriction::complexTypePtr(xs__complexType *complexType)
{ complexTypeRef = complexType;
}

xs__simpleType *xs__restriction::simpleTypePtr() const
{ return simpleTypeRef;
}

xs__complexType *xs__restriction::complexTypePtr() const
{ return complexTypeRef;
}

xs__list::xs__list()
{ itemTypeRef = NULL;
}

int xs__list::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema list" << endl;
  if (restriction)
    restriction->traverse(schema);
  for (vector<xs__simpleType>::iterator i = simpleType.begin(); i != simpleType.end(); ++i)
    (*i).traverse(schema);
  itemTypeRef = NULL;
  const char *token = qname_token(itemType, schema.targetNamespace);
  if (token)
  { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
      if (!strcmp((*i).name, token))
      { itemTypeRef = &(*i);
        if (vflag)
          cerr << "Found list itemType " << (token?token:"") << endl;
        break;
      }
  }
  if (!itemTypeRef)
  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
    { xs__schema *s = (*i).schemaPtr();
      if (s)
      { token = qname_token(itemType, s->targetNamespace);
        if (token)
        { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
            if (!strcmp((*j).name, token))
            { itemTypeRef = &(*j);
              if (vflag)
                cerr << "Found list itemType " << (token?token:"") << endl;
              break;
            }
          break;
        }
      }
    }
  }
  if (itemType && !itemTypeRef)
  { if (is_builtin_qname(itemType))
      schema.builtinType(itemType);
    else
      cerr << "Warning: could not find list itemType '" << itemType << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
  }
  return SOAP_OK;
}

void xs__list::itemTypePtr(xs__simpleType *simpleType)
{ itemTypeRef = simpleType;
}

xs__simpleType *xs__list::itemTypePtr() const
{ return itemTypeRef;
}

int xs__union::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema union" << endl;
  for (vector<xs__simpleType>::iterator i = simpleType.begin(); i != simpleType.end(); ++i)
    (*i).traverse(schema);
  return SOAP_OK;
}

int xs__all::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema all" << endl;
  for (vector<xs__element>::iterator i = element.begin(); i != element.end(); ++i)
    (*i).traverse(schema);
  return SOAP_OK;
}

xs__choice::xs__choice()
{ schemaRef = NULL;
}

int xs__choice::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema choice" << endl;
  schemaRef = &schema;
  for (vector<xs__group>::iterator gp = group.begin(); gp != group.end(); ++gp)
    (*gp).traverse(schema);
  for (vector<xs__choice>::iterator ch = choice.begin(); ch != choice.end(); ++ch)
    (*ch).traverse(schema);
  for (vector<xs__sequence*>::iterator sq = sequence.begin(); sq != sequence.end(); ++sq)
    (*sq)->traverse(schema);
  for (vector<xs__element>::iterator el = element.begin(); el != element.end(); ++el)
    (*el).traverse(schema);
  for (vector<xs__any>::iterator an = any.begin(); an != any.end(); ++an)
    (*an).traverse(schema);
  return SOAP_OK;
}

void xs__choice::schemaPtr(xs__schema *schema)
{ schemaRef = schema;
}

xs__schema *xs__choice::schemaPtr() const
{ return schemaRef;
}

int xs__sequence::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema sequence" << endl;
  for (vector<xs__element>::iterator el = element.begin(); el != element.end(); ++el)
    (*el).traverse(schema);
  for (vector<xs__group>::iterator gp = group.begin(); gp != group.end(); ++gp)
    (*gp).traverse(schema);
  for (vector<xs__choice>::iterator ch = choice.begin(); ch != choice.end(); ++ch)
    (*ch).traverse(schema);
  for (vector<xs__sequence*>::iterator sq = sequence.begin(); sq != sequence.end(); ++sq)
    (*sq)->traverse(schema);
  for (vector<xs__any>::iterator an = any.begin(); an != any.end(); ++an)
    (*an).traverse(schema);
  return SOAP_OK;
}

xs__attributeGroup::xs__attributeGroup()
{ schemaRef = NULL;
  attributeGroupRef = NULL;
}

int xs__attributeGroup::traverse(xs__schema& schema)
{ if (vflag)
    cerr << "attributeGroup" << endl;
  schemaRef = &schema;
  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
    (*at).traverse(schema);
  for (vector<xs__attributeGroup>::iterator ag = attributeGroup.begin(); ag != attributeGroup.end(); ++ag)
    (*ag).traverse(schema);
  attributeGroupRef = NULL;
  if (ref)
  { const char *token = qname_token(ref, schema.targetNamespace);
    if (token)
    { for (vector<xs__attributeGroup>::iterator i = schema.attributeGroup.begin(); i != schema.attributeGroup.end(); ++i)
        if (!strcmp((*i).name, token))
        { attributeGroupRef = &(*i);
          if (vflag)
              cerr << "Found attributeGroup " << (name?name:"") << " ref " << (token?token:"") << endl;
          break;
        }
    }
    if (!attributeGroupRef)
    { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
      { xs__schema *s = (*i).schemaPtr();
        if (s)
        { token = qname_token(ref, s->targetNamespace);
          if (token)
          { for (vector<xs__attributeGroup>::iterator j = s->attributeGroup.begin(); j != s->attributeGroup.end(); ++j)
              if (!strcmp((*j).name, token))
              { attributeGroupRef = &(*j);
                if (vflag)
                    cerr << "Found attribute Group " << (name?name:"") << " ref " << (token?token:"") << endl;
                break;
              }
            break;
          }
        }
      }
    }
    if (!attributeGroupRef)
      cerr << "Warning: could not find attributeGroup '" << (name?name:"") << "' ref '" << (ref?ref:"") << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
  }
  return SOAP_OK;
}

void xs__attributeGroup::schemaPtr(xs__schema *schema)
{ schemaRef = schema;
}

void xs__attributeGroup::attributeGroupPtr(xs__attributeGroup *attributeGroup)
{ attributeGroupRef = attributeGroup;
}

xs__schema *xs__attributeGroup::schemaPtr() const
{ return schemaRef;
}

xs__attributeGroup *xs__attributeGroup::attributeGroupPtr() const
{ return attributeGroupRef;
}

int xs__any::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema any" << endl;
  for (vector<xs__element>::iterator i = element.begin(); i != element.end(); ++i)
    (*i).traverse(schema);
  return SOAP_OK;
}

xs__group::xs__group()
{ schemaRef = NULL;
  groupRef = NULL;
}

int xs__group::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema group" << endl;
  schemaRef = &schema;
  if (all)
    all->traverse(schema);
  else if (choice)
    choice->traverse(schema);
  else if (sequence)
    sequence->traverse(schema);
  groupRef = NULL;
  if (ref)
  { const char *token = qname_token(ref, schema.targetNamespace);
    if (token)
    { for (vector<xs__group>::iterator i = schema.group.begin(); i != schema.group.end(); ++i)
        if (!strcmp((*i).name, token))
        { groupRef = &(*i);
          if (vflag)
              cerr << "Found group " << (name?name:"") << " ref " << (token?token:"") << endl;
          break;
        }
    }
    if (!groupRef)
    { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
      { xs__schema *s = (*i).schemaPtr();
        if (s)
        { token = qname_token(ref, s->targetNamespace);
          if (token)
          { for (vector<xs__group>::iterator j = s->group.begin(); j != s->group.end(); ++j)
              if (!strcmp((*j).name, token))
              { groupRef = &(*j);
                if (vflag)
                    cerr << "Found group " << (name?name:"") << " ref " << (token?token:"") << endl;
                break;
              }
            break;
          }
        }
      }
    }
    if (!groupRef)
      cerr << "Warning: could not find group '" << (name?name:"") << "' ref '" << (ref?ref:"") << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
  }
  return SOAP_OK;
}

void xs__group::schemaPtr(xs__schema *schema)
{ schemaRef = schema;
}

xs__schema* xs__group::schemaPtr() const
{ return schemaRef;
}

void xs__group::groupPtr(xs__group *group)
{ groupRef = group;
}

xs__group* xs__group::groupPtr() const
{ return groupRef;
}

int xs__enumeration::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema enumeration" << endl;
  return SOAP_OK;
}

int xs__pattern::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema pattern" << endl;
  return SOAP_OK;
}

////////////////////////////////////////////////////////////////////////////////
//
//	I/O
//
////////////////////////////////////////////////////////////////////////////////

ostream &operator<<(ostream &o, const xs__schema &e)
{ if (!e.soap)
  { struct soap soap;
    soap_init2(&soap, SOAP_IO_DEFAULT, SOAP_XML_TREE | SOAP_C_UTFSTRING);
    soap_set_namespaces(&soap, namespaces);
    e.soap_serialize(&soap);
    soap_begin_send(&soap);
    e.soap_out(&soap, "xs:schema", 0, NULL);
    soap_end_send(&soap);
    soap_end(&soap);
    soap_done(&soap);
  }
  else
  { ostream *os = e.soap->os;
    e.soap->os = &o;
    e.soap_serialize(e.soap);
    soap_begin_send(e.soap);
    e.soap_out(e.soap, "xs:schema", 0, NULL);
    soap_end_send(e.soap);
    e.soap->os = os;
  }
  return o;
}

istream &operator>>(istream &i, xs__schema &e)
{ if (!e.soap)
  { e.soap = soap_new();
    soap_set_namespaces(e.soap, namespaces);
  }
  istream *is = e.soap->is;
  e.soap->is = &i;
  if (soap_begin_recv(e.soap)
   || !e.soap_in(e.soap, "xs:schema", NULL)
   || soap_end_recv(e.soap))
  { // handle error? Note: e.soap->error is set and app should check
  }
  e.soap->is = is;
  return i;
}