~ifolder-dev/simias/trunk-packaging

SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_get_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p, const char *tag, const char *type)

472

{

473

if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))

474

soap_getindependent(soap);

475

return p;

476

}

477

478

SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_in_SOAP_ENV__Fault(struct soap *soap, const char *tag, struct SOAP_ENV__Fault *a, const char *type)

479

{

480

short soap_flag_faultcode = 1, soap_flag_faultstring = 1, soap_flag_faultactor = 1, soap_flag_detail = 1, soap_flag_SOAP_ENV__Code = 1, soap_flag_SOAP_ENV__Reason = 1, soap_flag_SOAP_ENV__Detail = 1;

481

if (soap_element_begin_in(soap, tag))

482

return NULL;

483

if (*soap->type && soap_match_tag(soap, soap->type, type))

484

{ soap->error = SOAP_TYPE_MISMATCH;

485

soap_revert(soap);

486

return NULL;

487

}

488

if (soap->null)

489

{ if (soap->mode & SOAP_XML_NIL)

490

{ soap->error = SOAP_NULL;

491

return NULL;

492

}

493

else

494

return a;

495

}

496

if (!*soap->href)

497

{ a = (struct SOAP_ENV__Fault *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0);

498

if (!a)

499

return NULL;

500

if (soap->alloced)

501

soap_default_SOAP_ENV__Fault(soap, a);

502

if (soap->body)

503

{ for (;;)

504

{ soap->error = SOAP_TAG_MISMATCH;

505

if (soap_flag_faultcode && soap->error == SOAP_TAG_MISMATCH)

506

if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))

507

{ soap_flag_faultcode = 0;

508

continue;

509

}

510

if (soap_flag_faultstring && soap->error == SOAP_TAG_MISMATCH)

511

if (soap_in_string(soap, "faultstring", &a->faultstring, ""))

512

{ soap_flag_faultstring = 0;

513

continue;

514

}

515

if (soap_flag_faultactor && soap->error == SOAP_TAG_MISMATCH)

516

if (soap_in_string(soap, "faultactor", &a->faultactor, ""))

517

{ soap_flag_faultactor = 0;

518

continue;

519

}

520

if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)

521

if (soap_in_string(soap, "detail", &a->detail, ""))

522

{ soap_flag_detail = 0;

523

continue;

524

}

525

if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)

526

if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))

527

{ soap_flag_SOAP_ENV__Code = 0;

528

continue;

529

}

530

if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)

531

if (soap_in_string(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))

532

{ soap_flag_SOAP_ENV__Reason = 0;

533

continue;

534

}

535

if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)

536

if (soap_in_string(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))

537

{ soap_flag_SOAP_ENV__Detail = 0;

538

continue;

539

}

540

if (soap->error == SOAP_TAG_MISMATCH)

541

soap->error = soap_ignore_element(soap);

542

if (soap->error == SOAP_NO_TAG)

543

break;

544

if (soap->error)

545

{ return NULL;

546

}

547

}

548

if (soap_element_end_in(soap, tag))

549

return NULL;

550

}

551

}

552

else

553

{ a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0), SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault));

554

if (soap->alloced)

555

soap_default_SOAP_ENV__Fault(soap, a);

556

if (soap->body && soap_element_end_in(soap, tag))

557

return NULL;

558

}

559

return a;

560

}

561

562

#endif

563

564

#ifndef WITH_NOGLOBAL

565

566

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code const*a)

567

{

568

if (!soap_reference(soap, a, SOAP_TYPE_SOAP_ENV__Code))

569

soap_mark_SOAP_ENV__Code(soap, a);

570

}

571

572

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)

573

{

574

soap_embedded(soap, &a->SOAP_ENV__Value, SOAP_TYPE__QName);

575

soap_mark__QName(soap, &a->SOAP_ENV__Value);

576

soap_embedded(soap, &a->SOAP_ENV__Node, SOAP_TYPE_string);

577

soap_mark_string(soap, &a->SOAP_ENV__Node);

578

soap_embedded(soap, &a->SOAP_ENV__Role, SOAP_TYPE_string);

579

soap_mark_string(soap, &a->SOAP_ENV__Role);

580

}

581

582

SOAP_FMAC1 void SOAP_FMAC2 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)

583

{

584

soap_default__QName(soap, &a->SOAP_ENV__Value);

585

soap_default_string(soap, &a->SOAP_ENV__Node);

586

soap_default_string(soap, &a->SOAP_ENV__Role);

587

}

588

589

SOAP_FMAC1 int SOAP_FMAC2 soap_put_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a, const char *tag, const char *type)

590

{

591

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_SOAP_ENV__Code);

592

if (i >= 0)

593

soap_out_SOAP_ENV__Code(soap, tag, i, a, type);

594

return soap_putindependent(soap);

595

}

596

597

SOAP_FMAC1 int SOAP_FMAC2 soap_out_SOAP_ENV__Code(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Code *a, const char *type)

598

{

599

soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type);

600

soap_out__QName(soap, "SOAP-ENV:Value", -1, &a->SOAP_ENV__Value, "");

601

soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, "");

602

soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, "");

603

soap_element_end_out(soap, tag);

604

return SOAP_OK;

605

}

606

607

SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_get_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p, const char *tag, const char *type)

608

{

609

if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))

610

soap_getindependent(soap);

611

return p;

612

}

613

614

SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_in_SOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code *a, const char *type)

615

{

616

short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Node = 1, soap_flag_SOAP_ENV__Role = 1;

617

if (soap_element_begin_in(soap, tag))

618

return NULL;

619

if (*soap->type && soap_match_tag(soap, soap->type, type))

620

{ soap->error = SOAP_TYPE_MISMATCH;

621

soap_revert(soap);

622

return NULL;

623

}

624

if (soap->null)

625

{ if (soap->mode & SOAP_XML_NIL)

626

{ soap->error = SOAP_NULL;

627

return NULL;

628

}

629

else

630

return a;

631

}

632

if (!*soap->href)

633

{ a = (struct SOAP_ENV__Code *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);

634

if (!a)

635

return NULL;

636

if (soap->alloced)

637

soap_default_SOAP_ENV__Code(soap, a);

638

if (soap->body)

639

{ for (;;)

640

{ soap->error = SOAP_TAG_MISMATCH;

641

if (soap_flag_SOAP_ENV__Value && soap->error == SOAP_TAG_MISMATCH)

642

if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))

643

{ soap_flag_SOAP_ENV__Value = 0;

644

continue;

645

}

646

if (soap_flag_SOAP_ENV__Node && soap->error == SOAP_TAG_MISMATCH)

647

if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, ""))

648

{ soap_flag_SOAP_ENV__Node = 0;

649

continue;

650

}

651

if (soap_flag_SOAP_ENV__Role && soap->error == SOAP_TAG_MISMATCH)

652

if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, ""))

653

{ soap_flag_SOAP_ENV__Role = 0;

654

continue;

655

}

656

if (soap->error == SOAP_TAG_MISMATCH)

657

soap->error = soap_ignore_element(soap);

658

if (soap->error == SOAP_NO_TAG)

659

break;

660

if (soap->error)

661

{ return NULL;

662

}

663

}

664

if (soap_element_end_in(soap, tag))

665

return NULL;

666

}

667

}

668

else

669

{ a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0), SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code));

670

if (soap->alloced)

671

soap_default_SOAP_ENV__Code(soap, a);

672

if (soap->body && soap_element_end_in(soap, tag))

673

return NULL;

674

}

675

return a;

676

}

677

678

#endif

679

680

#ifndef WITH_NOGLOBAL

681

682

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header const*a)

683

{

684

if (!soap_reference(soap, a, SOAP_TYPE_SOAP_ENV__Header))

685

soap_mark_SOAP_ENV__Header(soap, a);

686

}

687

688

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)

689

{

690

/* transient dummy skipped */

691

}

692

693

SOAP_FMAC1 void SOAP_FMAC2 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)

694

{

695

/* transient dummy skipped */

696

}

697

698

SOAP_FMAC1 int SOAP_FMAC2 soap_put_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a, const char *tag, const char *type)

699

{

700

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_SOAP_ENV__Header);

701

if (i >= 0)

702

soap_out_SOAP_ENV__Header(soap, tag, i, a, type);

703

return soap_putindependent(soap);

704

}

705

706

SOAP_FMAC1 int SOAP_FMAC2 soap_out_SOAP_ENV__Header(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Header *a, const char *type)

707

{

708

soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type);

709

/* transient dummy skipped */

710

soap_element_end_out(soap, tag);

711

return SOAP_OK;

712

}

713

714

SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_get_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p, const char *tag, const char *type)

715

{

716

if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))

717

soap_getindependent(soap);

718

return p;

719

}

720

721

SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_in_SOAP_ENV__Header(struct soap *soap, const char *tag, struct SOAP_ENV__Header *a, const char *type)

722

{;

723

if (soap_element_begin_in(soap, tag))

724

return NULL;

725

if (*soap->type && soap_match_tag(soap, soap->type, type))

726

{ soap->error = SOAP_TYPE_MISMATCH;

727

soap_revert(soap);

728

return NULL;

729

}

730

if (soap->null)

731

{ if (soap->mode & SOAP_XML_NIL)

732

{ soap->error = SOAP_NULL;

733

return NULL;

734

}

735

else

736

return a;

737

}

738

if (!*soap->href)

739

{ a = (struct SOAP_ENV__Header *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0);

740

if (!a)

741

return NULL;

742

if (soap->alloced)

743

soap_default_SOAP_ENV__Header(soap, a);

744

if (soap->body)

745

{ for (;;)

746

{ soap->error = SOAP_TAG_MISMATCH;

747

/* transient dummy skipped */

748

if (soap->error == SOAP_TAG_MISMATCH)

749

soap->error = soap_ignore_element(soap);

750

if (soap->error == SOAP_NO_TAG)

751

break;

752

if (soap->error)

753

{ return NULL;

754

}

755

}

756

if (soap_element_end_in(soap, tag))

757

return NULL;

758

}

759

}

760

else

761

{ a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0), SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header));

762

if (soap->alloced)

763

soap_default_SOAP_ENV__Header(soap, a);

764

if (soap->body && soap_element_end_in(soap, tag))

765

return NULL;

766

}

767

return a;

768

}

769

770

#endif

771

772

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_ns__getQuote(struct soap *soap, struct ns__getQuote const*a)

773

{

774

if (!soap_reference(soap, a, SOAP_TYPE_ns__getQuote))

775

soap_mark_ns__getQuote(soap, a);

776

}

777

778

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_ns__getQuote(struct soap *soap, const struct ns__getQuote *a)

779

{

780

soap_embedded(soap, &a->symbol, SOAP_TYPE_string);

781

soap_mark_string(soap, &a->symbol);

782

}

783

784

SOAP_FMAC1 void SOAP_FMAC2 soap_default_ns__getQuote(struct soap *soap, struct ns__getQuote *a)

785

{

786

soap_default_string(soap, &a->symbol);

787

}

788

789

SOAP_FMAC1 int SOAP_FMAC2 soap_put_ns__getQuote(struct soap *soap, struct ns__getQuote *a, const char *tag, const char *type)

790

{

791

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_ns__getQuote);

792

if (i >= 0)

793

soap_out_ns__getQuote(soap, tag, i, a, type);

794

return soap_putindependent(soap);

795

}

796

797

SOAP_FMAC1 int SOAP_FMAC2 soap_out_ns__getQuote(struct soap *soap, const char *tag, int id, const struct ns__getQuote *a, const char *type)

798

{

799

soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns__getQuote), type);

800

soap_out_string(soap, "symbol", -1, &a->symbol, "");

801

soap_element_end_out(soap, tag);

802

return SOAP_OK;

803

}

804

805

SOAP_FMAC1 struct ns__getQuote * SOAP_FMAC2 soap_get_ns__getQuote(struct soap *soap, struct ns__getQuote *p, const char *tag, const char *type)

806

{

807

if ((p = soap_in_ns__getQuote(soap, tag, p, type)))

808

soap_getindependent(soap);

809

return p;

810

}

811

812

SOAP_FMAC1 struct ns__getQuote * SOAP_FMAC2 soap_in_ns__getQuote(struct soap *soap, const char *tag, struct ns__getQuote *a, const char *type)

813

{

814

short soap_flag_symbol = 1;

815

if (soap_element_begin_in(soap, tag))

816

return NULL;

817

if (*soap->type && soap_match_tag(soap, soap->type, type))

818

{ soap->error = SOAP_TYPE_MISMATCH;

819

soap_revert(soap);

820

return NULL;

821

}

822

if (soap->null)

823

{ if (soap->mode & SOAP_XML_NIL)

824

{ soap->error = SOAP_NULL;

825

return NULL;

826

}

827

else

828

return a;

829

}

830

if (!*soap->href)

831

{ a = (struct ns__getQuote *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__getQuote, sizeof(struct ns__getQuote), 0);

832

if (!a)

833

return NULL;

834

if (soap->alloced)

835

soap_default_ns__getQuote(soap, a);

836

if (soap->body)

837

{ for (;;)

838

{ soap->error = SOAP_TAG_MISMATCH;

839

if (soap_flag_symbol && soap->error == SOAP_TAG_MISMATCH)

840

if (soap_in_string(soap, "symbol", &a->symbol, ""))

841

{ soap_flag_symbol = 0;

842

continue;

843

}

844

if (soap->error == SOAP_TAG_MISMATCH)

845

soap->error = soap_ignore_element(soap);

846

if (soap->error == SOAP_NO_TAG)

847

break;

848

if (soap->error)

849

{ return NULL;

850

}

851

}

852

if (soap_element_end_in(soap, tag))

853

return NULL;

854

}

855

}

856

else

857

{ a = (struct ns__getQuote *)soap_id_forward(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__getQuote, sizeof(struct ns__getQuote), 0), SOAP_TYPE_ns__getQuote, sizeof(struct ns__getQuote));

858

if (soap->alloced)

859

soap_default_ns__getQuote(soap, a);

860

if (soap->body && soap_element_end_in(soap, tag))

861

return NULL;

862

}

863

return a;

864

}

865

866

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_ns__getQuoteResponse(struct soap *soap, struct ns__getQuoteResponse const*a)

867

{

868

if (!soap_reference(soap, a, SOAP_TYPE_ns__getQuoteResponse))

869

soap_mark_ns__getQuoteResponse(soap, a);

870

}

871

872

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_ns__getQuoteResponse(struct soap *soap, const struct ns__getQuoteResponse *a)

873

{

874

soap_embedded(soap, &a->Result, SOAP_TYPE_PointerTofloat);

875

soap_mark_PointerTofloat(soap, &a->Result);

876

}

877

878

SOAP_FMAC1 void SOAP_FMAC2 soap_default_ns__getQuoteResponse(struct soap *soap, struct ns__getQuoteResponse *a)

879

{

880

soap_default_PointerTofloat(soap, &a->Result);

881

}

882

883

SOAP_FMAC1 int SOAP_FMAC2 soap_put_ns__getQuoteResponse(struct soap *soap, struct ns__getQuoteResponse *a, const char *tag, const char *type)

884

{

885

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_ns__getQuoteResponse);

886

if (i >= 0)

887

soap_out_ns__getQuoteResponse(soap, tag, i, a, type);

888

return soap_putindependent(soap);

889

}

890

891

SOAP_FMAC1 int SOAP_FMAC2 soap_out_ns__getQuoteResponse(struct soap *soap, const char *tag, int id, const struct ns__getQuoteResponse *a, const char *type)

892

{

893

soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns__getQuoteResponse), type);

894

if (a->Result)

895

soap_element_result(soap, "Result");

896

soap_out_PointerTofloat(soap, "Result", -1, &a->Result, "");

897

soap_element_end_out(soap, tag);

898

return SOAP_OK;

899

}

900

901

SOAP_FMAC1 struct ns__getQuoteResponse * SOAP_FMAC2 soap_get_ns__getQuoteResponse(struct soap *soap, struct ns__getQuoteResponse *p, const char *tag, const char *type)

902

{

903

if ((p = soap_in_ns__getQuoteResponse(soap, tag, p, type)))

904

soap_getindependent(soap);

905

return p;

906

}

907

908

SOAP_FMAC1 struct ns__getQuoteResponse * SOAP_FMAC2 soap_in_ns__getQuoteResponse(struct soap *soap, const char *tag, struct ns__getQuoteResponse *a, const char *type)

909

{

910

short soap_flag_Result = 1;

911

if (soap_element_begin_in(soap, tag))

912

return NULL;

913

if (*soap->type && soap_match_tag(soap, soap->type, type))

914

{ soap->error = SOAP_TYPE_MISMATCH;

915

soap_revert(soap);

916

return NULL;

917

}

918

if (soap->null)

919

{ if (soap->mode & SOAP_XML_NIL)

920

{ soap->error = SOAP_NULL;

921

return NULL;

922

}

923

else

924

return a;

925

}

926

if (!*soap->href)

927

{ a = (struct ns__getQuoteResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__getQuoteResponse, sizeof(struct ns__getQuoteResponse), 0);

928

if (!a)

929

return NULL;

930

if (soap->alloced)

931

soap_default_ns__getQuoteResponse(soap, a);

932

if (soap->body)

933

{ for (;;)

934

{ soap->error = SOAP_TAG_MISMATCH;

935

if (soap_flag_Result && soap->error == SOAP_TAG_MISMATCH)

936

if (soap_in_PointerTofloat(soap, "Result", &a->Result, ""))

937

{ soap_flag_Result = 0;

938

continue;

939

}

940

if (soap->error == SOAP_TAG_MISMATCH)

941

soap->error = soap_ignore_element(soap);

942

if (soap->error == SOAP_NO_TAG)

943

break;

944

if (soap->error)

945

{ return NULL;

946

}

947

}

948

if (soap_element_end_in(soap, tag))

949

return NULL;

950

}

951

}

952

else

953

{ a = (struct ns__getQuoteResponse *)soap_id_forward(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__getQuoteResponse, sizeof(struct ns__getQuoteResponse), 0), SOAP_TYPE_ns__getQuoteResponse, sizeof(struct ns__getQuoteResponse));

954

if (soap->alloced)

955

soap_default_ns__getQuoteResponse(soap, a);

956

if (soap->body && soap_element_end_in(soap, tag))

957

return NULL;

958

}

959

return a;

960

}

961

962

#ifndef WITH_NOGLOBAL

963

964

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)

965

{

966

if (!soap_reference(soap, a, SOAP_TYPE_PointerToSOAP_ENV__Code))

967

soap_mark_PointerToSOAP_ENV__Code(soap, a);

968

}

969

970

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)

971

{

972

if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))

973

soap_mark_SOAP_ENV__Code(soap, *a);

974

}

975

976

SOAP_FMAC1 void SOAP_FMAC2 soap_default_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **a)

977

{

978

*a = NULL;

979

}

980

981

SOAP_FMAC1 int SOAP_FMAC2 soap_put_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **a, const char *tag, const char *type)

982

{

983

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);

984

if (i >= 0)

985

soap_out_PointerToSOAP_ENV__Code(soap, tag, i, a, type);

986

return soap_putindependent(soap);

987

}

988

989

SOAP_FMAC1 int SOAP_FMAC2 soap_out_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Code *const*a, const char *type)

990

{

991

struct soap_plist *pp;

992

993

id = soap_embedded_id(soap, id, a, SOAP_TYPE_PointerToSOAP_ENV__Code);

994

if (!*a)

995

return soap_element_null(soap, tag, id, type);

996

i = soap_pointer_lookup(soap, *a, SOAP_TYPE_SOAP_ENV__Code, &pp);

997

if (i)

998

{ if (soap_is_embedded(soap, pp))

999

return soap_element_ref(soap, tag, id, i);

1000

if (soap_is_single(soap, pp))

1001

return soap_out_SOAP_ENV__Code(soap, tag, 0, *a, type);

1002

soap_set_embedded(soap, pp);

1003

return soap_out_SOAP_ENV__Code(soap, tag, i, *a, type);

1004

}

1005

return soap_out_SOAP_ENV__Code(soap, tag, soap_pointer_enter(soap, *a, SOAP_TYPE_SOAP_ENV__Code, &pp), *a, type);

1006

}

1007

1008

SOAP_FMAC1 struct SOAP_ENV__Code ** SOAP_FMAC2 soap_get_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **p, const char *tag, const char *type)

1009

{

1010

if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))

1011

soap_getindependent(soap);

1012

return p;

1013

}

1014

1015

SOAP_FMAC1 struct SOAP_ENV__Code ** SOAP_FMAC2 soap_in_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code **a, const char *type)

1016

{

1017

struct SOAP_ENV__Code *p;

1018

if (soap_element_begin_in(soap, tag))

1019

return NULL;

1020

if (soap->null)

1021

{ a = (struct SOAP_ENV__Code **)soap_id_enter(soap, soap->id, a, SOAP_TYPE_PointerToSOAP_ENV__Code, sizeof(struct SOAP_ENV__Code *), 1);

1022

if (a)

1023

*a = NULL;

1024

if (soap->body && soap_element_end_in(soap, tag))

1025

return NULL;

1026

}

1027

else if (!*soap->href)

1028

{ soap_revert(soap);

1029

if (a)

1030

{ if ((p = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))

1031

*a = p;

1032

else

1033

a = NULL;

1034

}

1035

else if ((p = soap_in_SOAP_ENV__Code(soap, tag, NULL, type)))

1036

{ a = (struct SOAP_ENV__Code **)soap_id_enter(soap, "", NULL, SOAP_TYPE_PointerToSOAP_ENV__Code, sizeof(struct SOAP_ENV__Code *), 0);

1037

if (a)

1038

*a = p;

1039

}

1040

}

1041

else

1042

{ a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_PointerToSOAP_ENV__Code, sizeof(struct SOAP_ENV__Code *), 1), SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);

1043

if (soap->body && soap_element_end_in(soap, tag))

1044

return NULL;

1045

}

1046

return a;

1047

}

1048

1049

#endif

1050

1051

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_PointerTofloat(struct soap *soap, float *const*a)

1052

{

1053

if (!soap_reference(soap, a, SOAP_TYPE_PointerTofloat))

1054

soap_mark_PointerTofloat(soap, a);

1055

}

1056

1057

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_PointerTofloat(struct soap *soap, float *const*a)

1058

{

1059

soap_reference(soap, *a, SOAP_TYPE_float);

1060

}

1061

1062

SOAP_FMAC1 void SOAP_FMAC2 soap_default_PointerTofloat(struct soap *soap, float **a)

1063

{

1064

*a = NULL;

1065

}

1066

1067

SOAP_FMAC1 int SOAP_FMAC2 soap_put_PointerTofloat(struct soap *soap, float **a, const char *tag, const char *type)

1068

{

1069

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_PointerTofloat);

1070

if (i >= 0)

1071

soap_out_PointerTofloat(soap, tag, i, a, type);

1072

return soap_putindependent(soap);

1073

}

1074

1075

SOAP_FMAC1 int SOAP_FMAC2 soap_out_PointerTofloat(struct soap *soap, const char *tag, int id, float *const*a, const char *type)

1076

{

1077

struct soap_plist *pp;

1078

1079

id = soap_embedded_id(soap, id, a, SOAP_TYPE_PointerTofloat);

1080

if (!*a)

1081

return soap_element_null(soap, tag, id, type);

1082

i = soap_pointer_lookup(soap, *a, SOAP_TYPE_float, &pp);

1083

if (i)

1084

{ if (soap_is_embedded(soap, pp))

1085

return soap_element_ref(soap, tag, id, i);

1086

if (soap_is_single(soap, pp))

1087

return soap_out_float(soap, tag, 0, *a, type);

1088

soap_set_embedded(soap, pp);

1089

return soap_out_float(soap, tag, i, *a, type);

1090

}

1091

return soap_out_float(soap, tag, soap_pointer_enter(soap, *a, SOAP_TYPE_float, &pp), *a, type);

1092

}

1093

1094

SOAP_FMAC1 float ** SOAP_FMAC2 soap_get_PointerTofloat(struct soap *soap, float **p, const char *tag, const char *type)

1095

{

1096

if ((p = soap_in_PointerTofloat(soap, tag, p, type)))

1097

soap_getindependent(soap);

1098

return p;

1099

}

1100

1101

SOAP_FMAC1 float ** SOAP_FMAC2 soap_in_PointerTofloat(struct soap *soap, const char *tag, float **a, const char *type)

1102

{

1103

float *p;

1104

if (soap_element_begin_in(soap, tag))

1105

return NULL;

1106

if (soap->null)

1107

{ a = (float **)soap_id_enter(soap, soap->id, a, SOAP_TYPE_PointerTofloat, sizeof(float *), 1);

1108

if (a)

1109

*a = NULL;

1110

if (soap->body && soap_element_end_in(soap, tag))

1111

return NULL;

1112

}

1113

else if (!*soap->href)

1114

{ soap_revert(soap);

1115

if (a)

1116

{ if ((p = soap_in_float(soap, tag, *a, type)))

1117

*a = p;

1118

else

1119

a = NULL;

1120

}

1121

else if ((p = soap_in_float(soap, tag, NULL, type)))

1122

{ a = (float **)soap_id_enter(soap, "", NULL, SOAP_TYPE_PointerTofloat, sizeof(float *), 0);

1123

if (a)

1124

*a = p;

1125

}

1126

}

1127

else

1128

{ a = (float **)soap_id_lookup(soap, soap->href, (void**)soap_id_enter(soap, soap->id, a, SOAP_TYPE_PointerTofloat, sizeof(float *), 1), SOAP_TYPE_float, sizeof(float), 0);

1129

if (soap->body && soap_element_end_in(soap, tag))

1130

return NULL;

1131

}

1132

return a;

1133

}

1134

1135

SOAP_FMAC1 void SOAP_FMAC2 soap_default__QName(struct soap *soap, char **a)

1136

{

1137

#ifdef SOAP_DEFAULT__QName

1138

*a = SOAP_DEFAULT__QName;

1139

#else

1140

*a = (char *)0;

1141

#endif

1142

}

1143

1144

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize__QName(struct soap *soap, char *const*a)

1145

{

1146

soap_reference(soap, *a, SOAP_TYPE__QName);

1147

}

1148

1149

SOAP_FMAC1 void SOAP_FMAC2 soap_mark__QName(struct soap *soap, char *const*a)

1150

{

1151

soap_reference(soap, *a, SOAP_TYPE__QName);

1152

}

1153

1154

SOAP_FMAC1 int SOAP_FMAC2 soap_put__QName(struct soap *soap, char **a, const char *tag, const char *type)

1155

{

1156

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE__QName);

1157

if (i >= 0)

1158

soap_out__QName(soap, tag, i, a, type);

1159

return soap_putindependent(soap);

1160

}

1161

1162

SOAP_FMAC1 int SOAP_FMAC2 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)

1163

{

1164

return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);

1165

}

1166

1167

SOAP_FMAC1 char ** SOAP_FMAC2 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)

1168

{

1169

if ((p = soap_in__QName(soap, tag, p, type)))

1170

soap_getindependent(soap);

1171

return p;

1172

}

1173

1174

SOAP_FMAC1 char * * SOAP_FMAC2 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)

1175

{

1176

return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2);

1177

}

1178

1179

SOAP_FMAC1 void SOAP_FMAC2 soap_default_string(struct soap *soap, char **a)

1180

{

1181

#ifdef SOAP_DEFAULT_string

1182

*a = SOAP_DEFAULT_string;

1183

#else

1184

*a = (char *)0;

1185

#endif

1186

}

1187

1188

SOAP_FMAC1 void SOAP_FMAC2 soap_serialize_string(struct soap *soap, char *const*a)

1189

{

1190

soap_reference(soap, *a, SOAP_TYPE_string);

1191

}

1192

1193

SOAP_FMAC1 void SOAP_FMAC2 soap_mark_string(struct soap *soap, char *const*a)

1194

{

1195

soap_reference(soap, *a, SOAP_TYPE_string);

1196

}

1197

1198

SOAP_FMAC1 int SOAP_FMAC2 soap_put_string(struct soap *soap, char **a, const char *tag, const char *type)

1199

{

1200

int i = soap_embed_element(soap, (void*)a, tag, SOAP_TYPE_string);

1201

if (i >= 0)

1202

soap_out_string(soap, tag, i, a, type);

1203

return soap_putindependent(soap);

1204

}

1205

1206

SOAP_FMAC1 int SOAP_FMAC2 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)

1207

{

1208

return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);

1209

}

1210

1211

SOAP_FMAC1 char ** SOAP_FMAC2 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)

1212

{

1213

if ((p = soap_in_string(soap, tag, p, type)))

1214

soap_getindependent(soap);

1215

return p;

1216

}

1217

1218

SOAP_FMAC1 char * * SOAP_FMAC2 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)

1219

{

1220

return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1);

1221

}

1222

#ifdef __cplusplus

1223

}

1224

#endif

1225

1226

/* end of soapC.c */

Older »