perfs.cc

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

#include "perf.hh"


#define TestOneway_dispatch_impl

unsigned char TestOneway_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 (!strcmp(IT_s,"test_no_param")) {
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        if (!IT_r.tcAssert ("\
Ro~test_no_param~>{v},O{}\
"))
            return 1;

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                ((TestOneway*)IT_pp)->test_no_param (IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }
        IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env);
        return 1;
    }

    else if (!strcmp(IT_s,"test_prim_args")) {
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        if (!IT_r.tcAssert ("\
Ro~test_prim_args~+shortVal{s},+longVal{l},+floatVal{f},+doubleVal{d},+charVal{c},+stringVal{0},>{v},O{}\
"))
            return 1;
        CORBA::Short shortVal;

        IT_r >> shortVal;

        CORBA::Long longVal;

        IT_r >> longVal;

        CORBA::Float floatVal;

        IT_r >> floatVal;

        CORBA::Double doubleVal;

        IT_r >> doubleVal;

        CORBA::Char charVal;

        IT_r >> charVal;

        char * stringVal;

        IT_r.decodeStringOp(stringVal);

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                ((TestOneway*)IT_pp)->test_prim_args ( shortVal,  longVal,  floatVal,  doubleVal,  charVal,  stringVal, IT_env);

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





        CORBA::string_free (stringVal);
        IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env);





        return 1;
    }

    else if (!strcmp(IT_s,"test_struct")) {
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        if (!IT_r.tcAssert ("\
Ro~test_struct~+structVal{R~PerfStruct~shortVal{s},longVal{l},floatVal{f},doubleVal{d},charVal{c},stringVal{0}},>{v},O{}\
"))
            return 1;
        PerfStruct structVal;

        structVal.decodeOp (IT_r);

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                ((TestOneway*)IT_pp)->test_struct ( structVal, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }
        IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env);
        return 1;
    }

    else if (!strcmp(IT_s,"test_prim_seq")) {
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        if (!IT_r.tcAssert ("\
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},>{v},O{}\
"))
            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);

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                ((TestOneway*)IT_pp)->test_prim_seq ( shortVal,  longVal,  floatVal,  doubleVal,  charVal,  stringVal, IT_env);

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





        IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env);





        return 1;
    }

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

        structVal.decodeOp (IT_r);

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                ((TestOneway*)IT_pp)->test_struct_seq ( structVal, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }
        IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env);
        return 1;
    }

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


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

        if (IT_f && !IT_r.isException (IT_env))
        	IT_f->inRequestPostM (IT_r, IT_env);
        if (!IT_r.isException (IT_env)) {
            try {
                ((TestOneway*)IT_pp)->test_struct_array ( arrayVal, IT_env);

            } catch (CORBA::SystemException &IT_exSys) {
            IT_env.propagate (&IT_exSys);
            } catch (CORBA::UserException &IT_exUsr) {
            IT_env.propagate (&IT_exUsr);
            }
        }
        structArray_free (arrayVal);
        IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env);
        return 1;
    }

    else if (IT_isTarget)
        IT_r.makeRuntimeException2 ();

    return 0;
}

#define TestReqReply_dispatch_impl

unsigned char TestReqReply_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 (!strcmp(IT_s,"test_prim_args")) {
        CORBA::Long IT_result;
        CORBA::Environment IT_env (IT_r);
        CORBA::Filter* IT_f = CORBA::Orbix.getFilter ();
        IT_r.tcPreAssert (
"\
Ro~test_prim_args~+shortVal{s},+longVal{l},+floatVal{f},+doubleVal{d},+charVal{c},+stringVal{0},*inoutShort{s},*inoutLong{l},*inoutFloat{f},*inoutDouble{d},*inoutChar{c},*inoutString{0},-outShort{s},-outLong{l},-outFloat{f},-outDouble{d},-outChar{c},-out\
");
        if (!IT_r.tcAssert ("\
String{0},>{l},N{}\
"))
            return 1;
        CORBA::Short shortVal;

        IT_r >> shortVal;

        CORBA::Long longVal;

        IT_r >> longVal;

        CORBA::Float floatVal;

        IT_r >> floatVal;

        CORBA::Double doubleVal;

        IT_r >> doubleVal;

        CORBA::Char charVal;

        IT_r >> charVal;

        char * stringVal;

        IT_r.decodeStringOp(stringVal);

        CORBA::Short inoutShort;

        IT_r >> inoutShort;

        CORBA::Long inoutLong;

        IT_r >> inoutLong;

        CORBA::Float inoutFloat;

        IT_r >> inoutFloat;

        CORBA::Double inoutDouble;

        IT_r >> inoutDouble;

        CORBA::Char inoutChar;

        IT_r >> inoutChar;

        char * inoutString;

        IT_r.decodeStringOp(inoutString);

        CORBA::Short outShort;

        CORBA::Long outLong;

        CORBA::Float outFloat;

        CORBA::Double outDouble;

        CORBA::Char outChar;

        char * 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_args ( 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);
            }
        }





        CORBA::string_free (stringVal);













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







            IT_r << inoutShort;


            IT_r << inoutLong;


            IT_r << inoutFloat;


            IT_r << inoutDouble;


            IT_r << inoutChar;


            IT_r.encodeStringOp (inoutString);
            CORBA::string_free (inoutString);


            IT_r << outShort;


            IT_r << outLong;


            IT_r << outFloat;


            IT_r << outDouble;


            IT_r << outChar;


            IT_r.encodeStringOp (outString);
            CORBA::string_free (outString);
            IT_r << IT_result;
            }

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

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