schema.cpp

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

        { token = qname_token(type, 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 element " << (name?name:"") << " complexType " << (token?token:"") << endl;
                break;
              }
            }
            break;
          }
        }
      }
    }
  }
  token = qname_token(substitutionGroup, schema.targetNamespace);
  if (token)
  { for (vector<xs__element>::iterator i = schema.element.begin(); i != schema.element.end(); ++i)
      if (!strcmp((*i).name, token))
      { (*i).substitutions.push_back(this);
        if (vflag)
          cerr << "Found substitutionGroup element " << (name?name:"") << " for abstract element " << (token?token:"") << endl;
        break;
      }
  }
  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(substitutionGroup, s->targetNamespace);
      if (token)
      { for (vector<xs__element>::iterator j = s->element.begin(); j != s->element.end(); ++j)
        { if (!strcmp((*j).name, token))
          { (*j).substitutions.push_back(this);
            if (vflag)
              cerr << "Found substitutionGroup element " << (name?name:"") << " for abstract element " << (token?token:"") << endl;
            break;
          }
        }
        break;
      }
    }
  }
  if (!elementRef && !simpleTypeRef && !complexTypeRef)
  { if (ref)
    { if (is_builtin_qname(ref))
        schema.builtinElement(ref);
      else
        cerr << "Warning: could not find element '" << (name?name:"") << "' ref '" << ref << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
    }
    else if (type)
    { if (is_builtin_qname(type))
        schema.builtinType(type);
      else
        cerr << "Warning: could not find element '" << (name?name:"") << "' type '" << type << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
    }
  }
  return SOAP_OK;
}

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

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

void xs__element::elementPtr(xs__element *element)
{ elementRef = element;
}

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

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

xs__element *xs__element::elementPtr() const
{ return elementRef;
}

const std::vector<xs__element*>* xs__element::substitutionsPtr() const
{ return &substitutions;
}

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

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

xs__simpleType::xs__simpleType()
{ schemaRef = NULL;
  level = 0;
}

int xs__simpleType::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema simpleType " << (name?name:"") << endl;
  schemaRef = &schema;
  if (list)
    list->traverse(schema);
  else if (restriction)
    restriction->traverse(schema);
  else if (union_)
    union_->traverse(schema);
  return SOAP_OK;
}

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

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

int xs__simpleType::baseLevel()
{ if (!level)
  { if (restriction)
    { level = -1;
      if (restriction->simpleTypePtr())
        level = restriction->simpleTypePtr()->baseLevel() + 1;
      else
        level = 2;
    }
    else if (list && list->restriction)
    { level = -1;
      if (list->restriction->simpleTypePtr())
        level = list->restriction->simpleTypePtr()->baseLevel() + 1;
      else
        level = 2;
    }
    else
      level = 1;
  }
  else if (level < 0)
  { cerr << "Cyclic restriction/extension base dependency" << endl;
  }
  return level;
}

xs__complexType::xs__complexType()
{ schemaRef = NULL;
  level = 0;
}

int xs__complexType::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema complexType " << (name?name:"") << endl;
  schemaRef = &schema;
  if (simpleContent)
    simpleContent->traverse(schema);
  else if (complexContent)
    complexContent->traverse(schema);
  else if (all)
    all->traverse(schema);
  else if (choice)
    choice->traverse(schema);
  else if (sequence)
    sequence->traverse(schema);
  else if (any)
    any->traverse(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);
  return SOAP_OK;
}

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

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

int xs__complexType::baseLevel()
{ if (!level)
  { if (simpleContent)
    { if (simpleContent->restriction)
      { level = -1;
        if (simpleContent->restriction->simpleTypePtr())
          level = simpleContent->restriction->simpleTypePtr()->baseLevel() + 1;
        else if (simpleContent->restriction->complexTypePtr())
          level = simpleContent->restriction->complexTypePtr()->baseLevel() + 1;
        else
          level = 2;
      }
      else if (simpleContent->extension)
      { level = -1;
        if (simpleContent->extension->simpleTypePtr())
          level = simpleContent->extension->simpleTypePtr()->baseLevel() + 1;
        else if (simpleContent->extension->complexTypePtr())
          level = simpleContent->extension->complexTypePtr()->baseLevel() + 1;
        else
          level = 2;
      }
    }
    else if (complexContent)
    { if (complexContent->restriction)
      { level = -1;
        if (complexContent->restriction->simpleTypePtr())
          level = complexContent->restriction->simpleTypePtr()->baseLevel() + 1;
        else if (complexContent->restriction->complexTypePtr())
          level = complexContent->restriction->complexTypePtr()->baseLevel() + 1;
        else
          level = 2;
      }
      else if (complexContent->extension)
      { level = -1;
        if (complexContent->extension->simpleTypePtr())
          level = complexContent->extension->simpleTypePtr()->baseLevel() + 1;
        else if (complexContent->extension->complexTypePtr())
          level = complexContent->extension->complexTypePtr()->baseLevel() + 1;
        else
          level = 2;
      }
    }
    else
      level = 1;
  }
  else if (level < 0)
  { cerr << "Cyclic restriction/extension base dependency" << endl;
  }
  return level;
}

int xs__simpleContent::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema simpleContent" << endl;
  if (extension)
    extension->traverse(schema);
  else if (restriction)
    restriction->traverse(schema);
  return SOAP_OK;
}

int xs__complexContent::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema complexContent" << endl;
  if (extension)
    extension->traverse(schema);
  else if (restriction)
    restriction->traverse(schema);
  return SOAP_OK;
}

xs__extension::xs__extension()
{ simpleTypeRef = NULL;
  complexTypeRef = NULL;
}

int xs__extension::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema extension " << (base?base:"") << endl;
  if (group)
    group->traverse(schema);
  else if (all)
    all->traverse(schema);
  else if (choice)
    choice->traverse(schema);
  else if (sequence)
    sequence->traverse(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);
  const char *token = qname_token(base, schema.targetNamespace);
  simpleTypeRef = NULL;
  if (token)
  { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
      if (!strcmp((*i).name, token))
      { simpleTypeRef = &(*i);
        if (vflag)
          cerr << "Found extension base type " << (token?token:"") << endl;
        break;
      }
  }
  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 extension 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 extension 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 extension 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 extension base type '" << base << "' in schema " << (schema.targetNamespace?schema.targetNamespace:"") << endl;
    }
    else
      cerr << "Extension has no base" << endl;
  }
  return SOAP_OK;
}

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

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

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

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

xs__restriction::xs__restriction()
{ simpleTypeRef = NULL;
  complexTypeRef = NULL;
}

int xs__restriction::traverse(xs__schema &schema)
{ if (vflag)
    cerr << "Analyzing schema restriction " << (base?base:"") << endl;
  if (group)
    group->traverse(schema);
  else if (all)
    all->traverse(schema);
  else if (choice)
    choice->traverse(schema);
  else if (sequence)
    sequence->traverse(schema);
  else
  { for (vector<xs__enumeration>::iterator en = enumeration.begin(); en != enumeration.end(); ++en)
      (*en).traverse(schema);
    for (vector<xs__pattern>::iterator pn = pattern.begin(); pn != pattern.end(); ++pn)
      (*pn).traverse(schema);
  }
  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
    (*at).traverse(schema);
  const char *token = qname_token(base, schema.targetNamespace);
  simpleTypeRef = NULL;
  if (token)
  { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
      if (!strcmp((*i).name, token))
      { simpleTypeRef = &(*i);
        if (vflag)
          cerr << "Found restriction base type " << (token?token:"") << endl;
        break;
      }
  }