~ifolder-dev/simias/trunk-packaging

cerr << "Warning: could not find port " << (name?name:"") << " binding " << (binding?binding:"") << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

334

return SOAP_OK;

335

}

336

337

void wsdl__port::bindingPtr(wsdl__binding *binding)

338

{ bindingRef = binding;

339

}

340

341

wsdl__binding *wsdl__port::bindingPtr() const

342

{ return bindingRef;

343

}

344

345

wsdl__binding::wsdl__binding()

346

{ portTypeRef = NULL;

347

}

348

349

wsdl__binding::~wsdl__binding()

350

{ }

351

352

int wsdl__binding::traverse(wsdl__definitions& definitions)

353

{ if (vflag)

354

cerr << "wsdl binding" << endl;

355

const char *token = qname_token(type, definitions.targetNamespace);

356

portTypeRef = NULL;

357

if (token)

358

{ for (vector<wsdl__portType>::iterator portType = definitions.portType.begin(); portType != definitions.portType.end(); ++portType)

359

{ if ((*portType).name && !strcmp((*portType).name, token))

360

{ portTypeRef = &(*portType);

361

if (vflag)

362

cerr << "Found binding " << (name?name:"") << " portType " << (token?token:"") << endl;

363

break;

364

}

365

}

366

}

367

else

368

{ for (vector<wsdl__import>::iterator import = definitions.import.begin(); import != definitions.import.end(); ++import)

369

{ wsdl__definitions *importdefinitions = (*import).definitionsPtr();

370

if (importdefinitions)

371

{ token = qname_token(type, importdefinitions->targetNamespace);

372

if (token)

373

{ for (vector<wsdl__portType>::iterator portType = importdefinitions->portType.begin(); portType != importdefinitions->portType.end(); ++portType)

374

{ if ((*portType).name && !strcmp((*portType).name, token))

375

{ portTypeRef = &(*portType);

376

if (vflag)

377

cerr << "Found binding " << (name?name:"") << " portType " << (token?token:"") << endl;

378

break;

379

}

380

}

381

}

382

}

383

}

384

}

385

if (!portTypeRef)

386

cerr << "Warning: could not find binding " << (name?name:"") << " portType " << (type?type:"") << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

387

for (vector<wsdl__binding_operation>::iterator i = operation.begin(); i != operation.end(); ++i)

388

(*i).traverse(definitions, portTypeRef);

389

return SOAP_OK;

390

}

391

392

void wsdl__binding::portTypePtr(wsdl__portType *portType)

393

{ portTypeRef = portType;

394

}

395

396

wsdl__portType *wsdl__binding::portTypePtr() const

397

{ return portTypeRef;

398

}

399

400

wsdl__binding_operation::wsdl__binding_operation()

401

{ operationRef = NULL;

402

}

403

404

wsdl__binding_operation::~wsdl__binding_operation()

405

{ }

406

407

int wsdl__binding_operation::traverse(wsdl__definitions& definitions, wsdl__portType *portTypeRef)

408

{ if (vflag)

409

cerr << "wsdl binding operation" << endl;

410

if (input)

411

input->traverse(definitions);

412

if (output)

413

output->traverse(definitions);

414

for (vector<wsdl__ext_fault>::iterator i = fault.begin(); i != fault.end(); ++i)

415

(*i).traverse(definitions);

416

operationRef = NULL;

417

if (portTypeRef)

418

{ for (vector<wsdl__operation>::iterator i = portTypeRef->operation.begin(); i != portTypeRef->operation.end(); ++i)

419

{ if ((*i).name && !strcmp((*i).name, name))

420

{ operationRef = &(*i);

421

if (vflag)

422

cerr << "Found operation " << (name?name:"") << endl;

423

break;

424

}

425

}

426

}

427

if (!operationRef)

428

cerr << "Warning: could not find operation " << (name?name:"") << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

429

else

430

{ for (vector<wsdl__ext_fault>::iterator i = fault.begin(); i != fault.end(); ++i)

431

{ if ((*i).name)

432

{ for (vector<wsdl__fault>::iterator j = operationRef->fault.begin(); j != operationRef->fault.end(); ++j)

433

{ if ((*j).name && !strcmp((*j).name, (*i).name))

434

{ (*i).messagePtr((*j).messagePtr());

435

if (vflag)

436

cerr << "Found fault " << ((*j).name?(*j).name:"") << " message " << endl;

437

break;

438

}

439

}

440

}

441

else if ((*i).soap__fault_ && (*i).soap__fault_->name) // try the soap:fault name, this is not elegant, but neither is WSDL 1.1

442

{ for (vector<wsdl__fault>::iterator j = operationRef->fault.begin(); j != operationRef->fault.end(); ++j)

443

{ if ((*j).name && !strcmp((*j).name, (*i).soap__fault_->name))

444

{ (*i).messagePtr((*j).messagePtr());

445

if (vflag)

446

cerr << "Found fault " << ((*j).name?(*j).name:"") << " message " << endl;

447

break;

448

}

449

}

450

}

451

if (!(*i).messagePtr())

452

cerr << "Warning: could not find soap:fault message in WSDL definitions " << (definitions.name?definitions.name:"") << " operation " << (name?name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

453

}

454

}

455

return SOAP_OK;

456

}

457

458

void wsdl__binding_operation::operationPtr(wsdl__operation *operation)

459

{ operationRef = operation;

460

}

461

462

wsdl__operation *wsdl__binding_operation::operationPtr() const

463

{ return operationRef;

464

}

465

466

int wsdl__ext_input::traverse(wsdl__definitions& definitions)

467

{ if (vflag)

468

cerr << "wsdl ext input" << endl;

469

for (vector<soap__header>::iterator i = soap__header_.begin(); i != soap__header_.end(); ++i)

470

(*i).traverse(definitions);

471

return SOAP_OK;

472

}

473

474

int wsdl__ext_output::traverse(wsdl__definitions& definitions)

475

{ if (vflag)

476

cerr << "wsdl ext output" << endl;

477

for (vector<soap__header>::iterator i = soap__header_.begin(); i != soap__header_.end(); ++i)

478

(*i).traverse(definitions);

479

return SOAP_OK;

480

}

481

482

wsdl__ext_fault::wsdl__ext_fault()

483

{ messageRef = NULL;

484

}

485

486

wsdl__ext_fault::~wsdl__ext_fault()

487

{ }

488

489

int wsdl__ext_fault::traverse(wsdl__definitions& definitions)

490

{ if (vflag)

491

cerr << "wsdl ext fault" << endl;

492

messageRef = NULL;

493

return SOAP_OK;

494

}

495

496

void wsdl__ext_fault::messagePtr(wsdl__message *message)

497

{ messageRef = message;

498

}

499

500

wsdl__message *wsdl__ext_fault::messagePtr() const

501

{ return messageRef;

502

}

503

504

int wsdl__portType::traverse(wsdl__definitions& definitions)

505

{ if (vflag)

506

cerr << "wsdl portType" << endl;

507

for (vector<wsdl__operation>::iterator i = operation.begin(); i != operation.end(); ++i)

508

(*i).traverse(definitions);

509

return SOAP_OK;

510

}

511

512

int wsdl__operation::traverse(wsdl__definitions& definitions)

513

{ if (vflag)

514

cerr << "wsdl operation" << endl;

515

if (input)

516

input->traverse(definitions);

517

if (output)

518

output->traverse(definitions);

519

for (vector<wsdl__fault>::iterator i = fault.begin(); i != fault.end(); ++i)

520

(*i).traverse(definitions);

521

return SOAP_OK;

522

}

523

524

wsdl__input::wsdl__input()

525

{ messageRef = NULL;

526

}

527

528

wsdl__input::~wsdl__input()

529

{ }

530

531

int wsdl__input::traverse(wsdl__definitions& definitions)

532

{ if (vflag)

533

cerr << "wsdl input" << endl;

534

const char *token = qname_token(message, definitions.targetNamespace);

535

messageRef = NULL;

536

if (token)

537

{ for (vector<wsdl__message>::iterator message = definitions.message.begin(); message != definitions.message.end(); ++message)

538

{ if ((*message).name && !strcmp((*message).name, token))

539

{ messageRef = &(*message);

540

if (vflag)

541

cerr << "Found input " << (name?name:"") << " message " << (token?token:"") << endl;

542

break;

543

}

544

}

545

}

546

else

547

{ for (vector<wsdl__import>::iterator import = definitions.import.begin(); import != definitions.import.end(); ++import)

548

{ wsdl__definitions *importdefinitions = (*import).definitionsPtr();

549

if (importdefinitions)

550

{ token = qname_token(message, importdefinitions->targetNamespace);

551

if (token)

552

{ for (vector<wsdl__message>::iterator message = importdefinitions->message.begin(); message != importdefinitions->message.end(); ++message)

553

{ if ((*message).name && !strcmp((*message).name, token))

554

{ messageRef = &(*message);

555

if (vflag)

556

cerr << "Found input " << (name?name:"") << " message " << (token?token:"") << endl;

557

break;

558

}

559

}

560

}

561

}

562

}

563

}

564

if (!messageRef)

565

cerr << "Warning: could not find input " << (name?name:"") << " message " << (message?message:"") << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

566

return SOAP_OK;

567

}

568

569

void wsdl__input::messagePtr(wsdl__message *message)

570

{ messageRef = message;

571

}

572

573

wsdl__message *wsdl__input::messagePtr() const

574

{ return messageRef;

575

}

576

577

wsdl__output::wsdl__output()

578

{ messageRef = NULL;

579

}

580

581

wsdl__output::~wsdl__output()

582

{ }

583

584

int wsdl__output::traverse(wsdl__definitions& definitions)

585

{ if (vflag)

586

cerr << "wsdl output" << endl;

587

const char *token = qname_token(message, definitions.targetNamespace);

588

messageRef = NULL;

589

if (token)

590

{ for (vector<wsdl__message>::iterator message = definitions.message.begin(); message != definitions.message.end(); ++message)

591

{ if ((*message).name && !strcmp((*message).name, token))

592

{ messageRef = &(*message);

593

if (vflag)

594

cerr << "Found output " << (name?name:"") << " message " << (token?token:"") << endl;

595

break;

596

}

597

}

598

}

599

else

600

{ for (vector<wsdl__import>::iterator import = definitions.import.begin(); import != definitions.import.end(); ++import)

601

{ wsdl__definitions *importdefinitions = (*import).definitionsPtr();

602

if (importdefinitions)

603

{ token = qname_token(message, importdefinitions->targetNamespace);

604

if (token)

605

{ for (vector<wsdl__message>::iterator message = importdefinitions->message.begin(); message != importdefinitions->message.end(); ++message)

606

{ if ((*message).name && !strcmp((*message).name, token))

607

{ messageRef = &(*message);

608

if (vflag)

609

cerr << "Found output " << (name?name:"") << " message " << (token?token:"") << endl;

610

break;

611

}

612

}

613

}

614

}

615

}

616

}

617

if (!messageRef)

618

cerr << "Warning: could not find output " << (name?name:"") << " message " << (message?message:"") << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

619

return SOAP_OK;

620

}

621

622

void wsdl__output::messagePtr(wsdl__message *message)

623

{ messageRef = message;

624

}

625

626

wsdl__message *wsdl__output::messagePtr() const

627

{ return messageRef;

628

}

629

630

wsdl__fault::wsdl__fault()

631

{ messageRef = NULL;

632

}

633

634

wsdl__fault::~wsdl__fault()

635

{ }

636

637

int wsdl__fault::traverse(wsdl__definitions& definitions)

638

{ if (vflag)

639

cerr << "wsdl fault" << endl;

640

const char *token = qname_token(message, definitions.targetNamespace);

641

messageRef = NULL;

642

if (token)

643

{ for (vector<wsdl__message>::iterator message = definitions.message.begin(); message != definitions.message.end(); ++message)

644

{ if ((*message).name && !strcmp((*message).name, token))

645

{ messageRef = &(*message);

646

if (vflag)

647

cerr << "Found fault " << (name?name:"") << " message " << (token?token:"") << endl;

648

break;

649

}

650

}

651

}

652

else

653

{ for (vector<wsdl__import>::iterator import = definitions.import.begin(); import != definitions.import.end(); ++import)

654

{ wsdl__definitions *importdefinitions = (*import).definitionsPtr();

655

if (importdefinitions)

656

{ token = qname_token(message, importdefinitions->targetNamespace);

657

if (token)

658

{ for (vector<wsdl__message>::iterator message = importdefinitions->message.begin(); message != importdefinitions->message.end(); ++message)

659

{ if ((*message).name && !strcmp((*message).name, token))

660

{ messageRef = &(*message);

661

if (vflag)

662

cerr << "Found output " << (name?name:"") << " message " << (token?token:"") << endl;

663

break;

664

}

665

}

666

}

667

}

668

}

669

}

670

if (!messageRef)

671

cerr << "Warning: could not find fault " << (name?name:"") << " message " << (message?message:"") << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

672

return SOAP_OK;

673

}

674

675

void wsdl__fault::messagePtr(wsdl__message *message)

676

{ messageRef = message;

677

}

678

679

wsdl__message *wsdl__fault::messagePtr() const

680

{ return messageRef;

681

}

682

683

int wsdl__message::traverse(wsdl__definitions& definitions)

684

{ if (vflag)

685

cerr << "wsdl message" << endl;

686

for (vector<wsdl__part>::iterator i = part.begin(); i != part.end(); ++i)

687

(*i).traverse(definitions);

688

return SOAP_OK;

689

}

690

691

wsdl__part::wsdl__part()

692

{ elementRef = NULL;

693

simpleTypeRef = NULL;

694

complexTypeRef = NULL;

695

}

696

697

wsdl__part::~wsdl__part()

698

{ }

699

700

int wsdl__part::traverse(wsdl__definitions& definitions)

701

{ if (vflag)

702

cerr << "wsdl part" << endl;

703

elementRef = NULL;

704

simpleTypeRef = NULL;

705

complexTypeRef = NULL;

706

if (definitions.types)

707

{ for (vector<xs__schema*>::iterator schema = definitions.types->xs__schema_.begin(); schema != definitions.types->xs__schema_.end(); ++schema)

708

{ const char *token = qname_token(element, (*schema)->targetNamespace);

709

if (token)

710

{ for (vector<xs__element>::iterator element = (*schema)->element.begin(); element != (*schema)->element.end(); ++element)

711

{ if ((*element).name && !strcmp((*element).name, token))

712

{ elementRef = &(*element);

713

if (vflag)

714

cerr << "Found part " << (name?name:"") << " element " << (token?token:"") << endl;

715

break;

716

}

717

}

718

}

719

token = qname_token(type, (*schema)->targetNamespace);

720

if (token)

721

{ for (vector<xs__simpleType>::iterator simpleType = (*schema)->simpleType.begin(); simpleType != (*schema)->simpleType.end(); ++simpleType)

722

{ if ((*simpleType).name && !strcmp((*simpleType).name, token))

723

{ simpleTypeRef = &(*simpleType);

724

if (vflag)

725

cerr << "Found part " << (name?name:"") << " simpleType " << (token?token:"") << endl;

726

break;

727

}

728

}

729

}

730

token = qname_token(type, (*schema)->targetNamespace);

731

if (token)

732

{ for (vector<xs__complexType>::iterator complexType = (*schema)->complexType.begin(); complexType != (*schema)->complexType.end(); ++complexType)

733

{ if ((*complexType).name && !strcmp((*complexType).name, token))

734

{ complexTypeRef = &(*complexType);

735

if (vflag)

736

cerr << "Found part " << (name?name:"") << " complexType " << (token?token:"") << endl;

737

break;

738

}

739

}

740

}

741

}

742

}

743

if (!elementRef && !simpleTypeRef && !complexTypeRef)

744

{ if (element)

745

{ if (is_builtin_qname(element))

746

definitions.builtinElement(element);

747

else

748

cerr << "Warning: could not find part " << (name?name:"") << " element " << element << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

749

}

750

else if (type)

751

{ if (is_builtin_qname(type))

752

definitions.builtinType(type);

753

else

754

cerr << "Warning: could not find part " << (name?name:"") << " type " << type << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

755

}

756

else

757

cerr << "Warning: could not find part " << (name?name:"") << " element or type" << " in WSDL definitions " << (definitions.name?definitions.name:"") << " namespace " << (definitions.targetNamespace?definitions.targetNamespace:"") << endl;

758

}

759

return SOAP_OK;

760

}

761

762

void wsdl__part::elementPtr(xs__element *element)

763

{ elementRef = element;

764

}

765

766

void wsdl__part::simpleTypePtr(xs__simpleType *simpleType)

767

{ simpleTypeRef = simpleType;

768

}

769

770

void wsdl__part::complexTypePtr(xs__complexType *complexType)

771

{ complexTypeRef = complexType;

772

}

773

774

xs__element *wsdl__part::elementPtr() const

775

{ return elementRef;

776

}

777

778

xs__simpleType *wsdl__part::simpleTypePtr() const

779

{ return simpleTypeRef;

780

}

781

782

xs__complexType *wsdl__part::complexTypePtr() const

783

{ return complexTypeRef;

784

}

785

786

int wsdl__types::traverse(wsdl__definitions& definitions)

787

{ if (vflag)

788

cerr << "wsdl types" << endl;

789

// import external schemas

790

again:

791

for (vector<xs__schema*>::iterator schema1 = xs__schema_.begin(); schema1 != xs__schema_.end(); ++schema1)

792

{ for (vector<xs__import>::iterator import = (*schema1)->import.begin(); import != (*schema1)->import.end(); ++import)

793

{ if ((*import).namespace_ && (*import).schemaLocation)

794

{ bool found = false;

795

for (vector<xs__schema*>::const_iterator schema2 = xs__schema_.begin(); schema2 != xs__schema_.end(); ++schema2)

796

{ if ((*schema2)->targetNamespace && !strcmp((*import).namespace_, (*schema2)->targetNamespace))

797

{ found = true;

798

break;

799

}

800

}

801

if (!found)

802

{ if ((*import).schemaPtr())

803

{ if (strcmp((*import).schemaPtr()->targetNamespace, (*import).namespace_))

804

cerr << "Schema import namespace " << (*import).namespace_ << " does not correspond to imported targetNamespace " << (*import).schemaPtr()->targetNamespace << endl;

805

else

806

{ xs__schema_.push_back((*import).schemaPtr());

807

goto again;

808

}

809

}

810

else

811

{ struct Namespace *p = definitions.soap->local_namespaces;

812

const char *s = (*import).schemaLocation;

813

if (s && (*import).namespace_)

814

{ if (p)

815

{ for (; p->id; p++)

816

{ if (p->in)

817

{ if (!soap_tag_cmp((*import).namespace_, p->in))

818

break;

819

}

820

if (p->ns)

821

{ if (!soap_tag_cmp((*import).namespace_, p->ns))

822

break;

823

}

824

}

825

}

826

else

827

fprintf(stderr, "Warning: no namespace table\n");

828

if (!iflag && (!p || !p->id)) // don't import any of the schemas in the .nsmap table (or when -i option is used)

829

{ xs__schema *importschema = new xs__schema(definitions.soap, s);

830

(*import).schemaPtr(importschema);

831

if (!importschema->targetNamespace)

832

importschema->targetNamespace = (*import).namespace_;

833

if (strcmp(importschema->targetNamespace, (*import).namespace_))

834

cerr << "Schema import namespace " << (*import).namespace_ << " does not correspond to imported targetNamespace " << importschema->targetNamespace << endl;

835

else

836

{ importschema->traverse();

837

xs__schema_.push_back(importschema);

838

goto again;

839

}

840

}

841

}

842

else if (vflag)

843

fprintf(stderr, "Warning: no schemaLocation for namespace '%s'\n", (*import).namespace_?(*import).namespace_:"");

844

}

845

}

846

}

847

}

848

}

849

for (vector<xs__schema*>::iterator schema2 = xs__schema_.begin(); schema2 != xs__schema_.end(); ++schema2)

850

{ // artificially extend the <import> of each schema to include others so when we traverse schemas we can resolve references

851

for (vector<xs__schema*>::iterator importschema = xs__schema_.begin(); importschema != xs__schema_.end(); ++importschema)

852

{ if (schema2 != importschema)

853

{ xs__import *import = new xs__import();

854

import->namespace_ = (*importschema)->targetNamespace;

855

import->schemaPtr(*importschema);

856

(*schema2)->import.push_back(*import);

857

}

858

}

859

for (vector<xs__import>::iterator import = (*schema2)->import.begin(); import != (*schema2)->import.end(); ++import)

860

{ if ((*import).namespace_)

861

{ bool found = false;

862

for (vector<xs__schema*>::const_iterator importschema = xs__schema_.begin(); importschema != xs__schema_.end(); ++importschema)

863

{ if ((*importschema)->targetNamespace && !strcmp((*import).namespace_, (*importschema)->targetNamespace))

864

{ found = true;

865

break;

866

}

867

}

868

if (!found)

869

cerr << "Schema import namespace " << (*import).namespace_ << " refers to a known external Schema" << endl;

870

}

871

else

872

cerr << "<xs:import> has no namespace" << endl;

873

}

874

}

875

for (vector<xs__schema*>::iterator schema3 = xs__schema_.begin(); schema3 != xs__schema_.end(); ++schema3)

876

{ (*schema3)->traverse();

877

if (vflag)

878

for (SetOfString::const_iterator i = (*schema3)->builtinTypes().begin(); i != (*schema3)->builtinTypes().end(); ++i)

879

cerr << "Schema builtin type: " << (*i) << endl;

880

definitions.builtinTypes((*schema3)->builtinTypes());

881

definitions.builtinElements((*schema3)->builtinElements());

882

definitions.builtinAttributes((*schema3)->builtinAttributes());

883

}

884

return SOAP_OK;

885

}

886

887

int wsdl__import::traverse(wsdl__definitions& definitions)

888

{ if (vflag)

889

cerr << "wsdl import" << endl;

890

definitionsRef = NULL;

891

if (location)

892

{ // parse imported definitions

893

definitionsRef = new wsdl__definitions(definitions.soap, location);

894

if (!definitionsRef)

895

return SOAP_EOF;

896

if (namespace_)

897

if (strcmp(namespace_, definitionsRef->targetNamespace))

898

cerr << "Import " << location << " namespace " << namespace_ << " does not match imported targetNamespace " << definitionsRef->targetNamespace << endl;

899

// merge <types>

900

if (definitionsRef->types)

901

{ if (definitions.types)

902

{ // import schemas

903

/* Removed: now handled by xs__schema::traverse()

904

for (vector<xs__schema>::iterator schema = definitions.types->xs__schema_.begin(); schema != definitions.types->xs__schema_.end(); ++schema)

905

{ for (vector<xs__schema>::iterator importschema = definitionsRef->types->xs__schema_.begin(); importschema != definitionsRef->types->xs__schema_.end(); ++importschema)

906

{ xs__import *import = new xs__import();

907

if (vflag)

908

cerr << "Importing schema " << (*importschema).targetNamespace << endl;

909

import->namespace_ = (*importschema).targetNamespace; // the schemaRef pointer will be set when traversing <types>

910

(*schema).import.push_back(*import);

911

}

912

}

913

914

// merge <types>, check for duplicates

915

for (vector<xs__schema*>::const_iterator importschema = definitionsRef->types->xs__schema_.begin(); importschema != definitionsRef->types->xs__schema_.end(); ++importschema)

916

{ bool found = false;

917

for (vector<xs__schema*>::const_iterator schema = definitions.types->xs__schema_.begin(); schema != definitions.types->xs__schema_.end(); ++schema)

918

{ if (!strcmp((*importschema)->targetNamespace, (*schema)->targetNamespace))

919

{ found = true;

920

break;

921

}

922

}

923

if (!found)

924

definitions.types->xs__schema_.push_back(*importschema);

925

}

926

}

927

else

928

definitions.types = definitionsRef->types;

929

}

930

// combine sets of builtin types, elements, and attributes

931

definitions.builtinTypes(definitionsRef->builtinTypes());

932

definitions.builtinElements(definitionsRef->builtinElements());

933

definitions.builtinAttributes(definitionsRef->builtinAttributes());

934

}

935

return SOAP_OK;

936

}

937

938

void wsdl__import::definitionsPtr(wsdl__definitions *definitions)

939

{ definitionsRef = definitions;

940

}

941

942

wsdl__definitions *wsdl__import::definitionsPtr() const

943

{ return definitionsRef;

944

}

945

946

wsdl__import::wsdl__import()

947

{ definitionsRef = NULL;

948

}

949

950

wsdl__import::~wsdl__import()

951

{ // if (definitionsRef)

952

// delete definitionsRef;

953

}

954

955

////////////////////////////////////////////////////////////////////////////////

956

957

// streams

958

959

////////////////////////////////////////////////////////////////////////////////

960

961

ostream &operator<<(ostream &o, const wsdl__definitions &e)

962

{ if (!e.soap)

963

{ struct soap soap;

964

soap_init2(&soap, SOAP_IO_DEFAULT, SOAP_XML_TREE | SOAP_C_UTFSTRING);

965

#ifdef WITH_NONAMESPACES

966

soap_set_namespaces(&soap, namespaces);

967

#endif

968

e.soap_serialize(&soap);

969

soap_begin_send(&soap);

970

e.soap_out(&soap, "wsdl:definitions", 0, NULL);

971

soap_end_send(&soap);

972

soap_end(&soap);

973

soap_done(&soap);

974

}

975

else

976

{ ostream *os = e.soap->os;

977

e.soap->os = &o;

978

e.soap_serialize(e.soap);

979

soap_begin_send(e.soap);

980

e.soap_out(e.soap, "wsdl:definitions", 0, NULL);

981

soap_end_send(e.soap);

982

e.soap->os = os;

983

}

984

return o;

985

}

986

987

istream &operator>>(istream &i, wsdl__definitions &e)

988

{ if (!e.soap)

989

e.soap = soap_new1(SOAP_XML_TREE | SOAP_C_UTFSTRING);

990

#ifdef WITH_NONAMESPACES

991

soap_set_namespaces(e.soap, namespaces);

992

#endif

993

istream *is = e.soap->is;

994

e.soap->is = &i;

995

if (soap_begin_recv(e.soap)

996

|| !e.soap_in(e.soap, "wsdl:definitions", NULL)

997

|| soap_end_recv(e.soap))

998

{ // handle error? Note: e.soap->error is set and app should check

999

}

1000

e.soap->is = is;

1001

return i;

1002

}

1003

1004

////////////////////////////////////////////////////////////////////////////////

1005

1006

// Miscellaneous

1007

1008

////////////////////////////////////////////////////////////////////////////////

1009

1010

int warn_ignore(struct soap *soap, const char *tag)

1011

{ // We don't warn if the omitted element was an annotation or a documentation in an unexpected place

1012

if (soap_match_tag(soap, tag, "xs:annotation") && soap_match_tag(soap, tag, "xs:documentation"))

1013

fprintf(stderr, "Warning: element '%s' at level %d was not recognized and will be ignored\n", tag, soap->level);

1014

return SOAP_OK;

1015

}

1016

1017

int show_ignore(struct soap *soap, const char *tag)

1018

{ warn_ignore(soap, tag);

1019

soap_print_fault_location(soap, stderr);

1020

return SOAP_OK;

1021

}

1022

Older »