perfs.cc

C++的CORBA程序源代码,isporb.1.1.1.tar.gz

ngVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},>{l},N{}\
"))
            return 1;
        PerfStruct structVal;

        structVal.decodeOp (IT_r);

        PerfStruct inoutStruct;

        inoutStruct.decodeOp (IT_r);

        PerfStruct* outStruct = NULL;

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                	IT_result = ((TestReqReply*)IT_pp)->test_struct_args ( structVal,  inoutStruct,  outStruct, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }



        if (!IT_r.isException (IT_env)) {
            if (!IT_r.convertToReply ("\
l\
", IT_env)) return 1;


            inoutStruct.encodeOp (IT_r);

            if (!outStruct) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outStruct).encodeOp (IT_r);
            delete outStruct;
            IT_r << IT_result;
            }

        else IT_r.makeSystemException (IT_env);
        return 1;
    }

    else if (!strcmp(IT_s,"test_prim_seq")) {
        CORBA::Long IT_result;
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        IT_r.tcPreAssert (
"\
Ro~test_prim_seq~+shortVal{S{s},0},+longVal{S{l},0},+floatVal{S{f},0},+doubleVal{S{d},0},+charVal{S{c},0},+stringVal{S{0},0},*inoutShort{S{s},0},*inoutLong{S{l},0},*inoutFloat{S{f},0},*inoutDouble{S{d},0},*inoutChar{S{c},0},*inoutString{S{0},0},-outShort\
");
        if (!IT_r.tcAssert ("\
{S{s},0},-outLong{S{l},0},-outFloat{S{f},0},-outDouble{S{d},0},-outChar{S{c},0},-outString{S{0},0},>{l},N{}\
"))
            return 1;
        shortSeq shortVal;

        shortVal.decodeOp (IT_r);

        longSeq longVal;

        longVal.decodeOp (IT_r);

        floatSeq floatVal;

        floatVal.decodeOp (IT_r);

        doubleSeq doubleVal;

        doubleVal.decodeOp (IT_r);

        charSeq charVal;

        charVal.decodeOp (IT_r);

        stringSeq stringVal;

        stringVal.decodeOp (IT_r);

        shortSeq inoutShort;

        inoutShort.decodeOp (IT_r);

        longSeq inoutLong;

        inoutLong.decodeOp (IT_r);

        floatSeq inoutFloat;

        inoutFloat.decodeOp (IT_r);

        doubleSeq inoutDouble;

        inoutDouble.decodeOp (IT_r);

        charSeq inoutChar;

        inoutChar.decodeOp (IT_r);

        stringSeq inoutString;

        inoutString.decodeOp (IT_r);

        shortSeq* outShort = NULL;

        longSeq* outLong = NULL;

        floatSeq* outFloat = NULL;

        doubleSeq* outDouble = NULL;

        charSeq* outChar = NULL;

        stringSeq* outString = NULL;

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                	IT_result = ((TestReqReply*)IT_pp)->test_prim_seq ( shortVal,  longVal,  floatVal,  doubleVal,  charVal,  stringVal,  inoutShort,  inoutLong,  inoutFloat,  inoutDouble,  inoutChar,  inoutString,  outShort,  outLong,  outFloat,  outDouble,  outChar,  outString, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }


















        if (!IT_r.isException (IT_env)) {
            if (!IT_r.convertToReply ("\
l\
", IT_env)) return 1;







            inoutShort.encodeOp (IT_r);


            inoutLong.encodeOp (IT_r);


            inoutFloat.encodeOp (IT_r);


            inoutDouble.encodeOp (IT_r);


            inoutChar.encodeOp (IT_r);


            inoutString.encodeOp (IT_r);

            if (!outShort) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outShort).encodeOp (IT_r);
            delete outShort;

            if (!outLong) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outLong).encodeOp (IT_r);
            delete outLong;

            if (!outFloat) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outFloat).encodeOp (IT_r);
            delete outFloat;

            if (!outDouble) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outDouble).encodeOp (IT_r);
            delete outDouble;

            if (!outChar) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outChar).encodeOp (IT_r);
            delete outChar;

            if (!outString) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outString).encodeOp (IT_r);
            delete outString;
            IT_r << IT_result;
            }

        else IT_r.makeSystemException (IT_env);
        return 1;
    }

    else if (!strcmp(IT_s,"test_struct_seq")) {
        CORBA::Long IT_result;
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        IT_r.tcPreAssert (
"\
Ro~test_struct_seq~+structVal{S{R~PerfStruct~shortVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},0},*inoutStruct{S{R~PerfStruct~shortVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},0},-outStruct{S{R~PerfStruct~sho\
");
        if (!IT_r.tcAssert ("\
rtVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},0},>{l},N{}\
"))
            return 1;
        structSeq structVal;

        structVal.decodeOp (IT_r);

        structSeq inoutStruct;

        inoutStruct.decodeOp (IT_r);

        structSeq* outStruct = NULL;

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                	IT_result = ((TestReqReply*)IT_pp)->test_struct_seq ( structVal,  inoutStruct,  outStruct, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }



        if (!IT_r.isException (IT_env)) {
            if (!IT_r.convertToReply ("\
l\
", IT_env)) return 1;


            inoutStruct.encodeOp (IT_r);

            if (!outStruct) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else

            (*outStruct).encodeOp (IT_r);
            delete outStruct;
            IT_r << IT_result;
            }

        else IT_r.makeSystemException (IT_env);
        return 1;
    }

    else if (!strcmp(IT_s,"test_struct_array")) {
        CORBA::Long IT_result;
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        IT_r.tcPreAssert (
"\
Ro~test_struct_array~+structVal{A{R~PerfStruct~shortVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},100},*inoutStruct{A{R~PerfStruct~shortVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},100},-outStruct{A{R~PerfStru\
");
        if (!IT_r.tcAssert ("\
ct~shortVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},100},>{l},N{}\
"))
            return 1;
        structArray_slice* structVal = new structArray;


        {
            PerfStruct* IT_elem = (PerfStruct*) structVal;
            for (unsigned long i0 = 0; i0 < 100; i0++, IT_elem++)
            IT_elem->decodeOp (IT_r);
        }

        structArray_slice* inoutStruct = new structArray;


        {
            PerfStruct* IT_elem = (PerfStruct*) inoutStruct;
            for (unsigned long i1 = 0; i1 < 100; i1++, IT_elem++)
            IT_elem->decodeOp (IT_r);
        }

        structArray_slice* outStruct = NULL;

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                	IT_result = ((TestReqReply*)IT_pp)->test_struct_array ( structVal,  inoutStruct,  outStruct, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }
        structArray_free (structVal);



        if (!IT_r.isException (IT_env)) {
            if (!IT_r.convertToReply ("\
l\
", IT_env)) return 1;

            if (!inoutStruct) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else


            {
                PerfStruct* IT_elem = (PerfStruct*) inoutStruct;
                for (unsigned long i2 = 0; i2 < 100; i2++, IT_elem++)
                IT_elem->encodeOp (IT_r);
            }
            structArray_free (inoutStruct);

            if (!outStruct) {
                IT_r.makeRuntimeException6 ();
                return 1;
            }
            else


            {
                PerfStruct* IT_elem = (PerfStruct*) outStruct;
                for (unsigned long i3 = 0; i3 < 100; i3++, IT_elem++)
                IT_elem->encodeOp (IT_r);
            }
            structArray_free (outStruct);
            IT_r << IT_result;
            }

        else IT_r.makeSystemException (IT_env);
        return 1;
    }

    else if (IT_isTarget)
        IT_r.makeRuntimeException2 ();

    return 0;
}

#define TestOneway_dkv_dispatch_impl

unsigned char TestOneway_dkv_dispatch::dispatch (CORBA::Request &IT_r, 
 unsigned char IT_isTarget, void *IT_pp) {
    if (!IT_pp)
       IT_pp = m_obj;
    const char *IT_s = IT_r.getOperation ();
    if (TestOneway_dispatch::dispatch (IT_r, 0,
         (TestOneway*)((TestOneway_dkv*)IT_pp))) {
   return 1;
    }

    else if (IT_isTarget)
        IT_r.makeRuntimeException2 ();

    return 0;
}

#include "perfC.cc"