perfc.cc

来自「C++的CORBA程序源代码,isporb.1.1.1.tar.gz」· CC 代码 · 共 2,440 行 · 第 1/5 页

    CORBA::EnvExcRaiser IT_raise (&IT_env);
    if (IT_env || m_isNull) {
        IT_raise.maybeRaise ();
        return 0;
    }
    CORBA::Request IT_r (this, "test_prim_args",IT_env,1,0);
    if (!IT_r.isException (IT_env)) {

        IT_r << shortVal;


        IT_r << longVal;


        IT_r << floatVal;


        IT_r << doubleVal;


        IT_r << charVal;


        IT_r.encodeStringOp (stringVal);


        IT_r << inoutShort;


        IT_r << inoutLong;


        IT_r << inoutFloat;


        IT_r << inoutDouble;


        IT_r << inoutChar;


        IT_r.encodeStringOp (inoutString);






    }

    IT_r.invoke (CORBA::Flags(0),IT_env);
    if (!IT_r.isException (IT_env)) {







        IT_r >> inoutShort;


        IT_r >> inoutLong;


        IT_r >> inoutFloat;


        IT_r >> inoutDouble;


        IT_r >> inoutChar;


        IT_r.decodeInOutStrOp(inoutString, 0);


        IT_r >> outShort;


        IT_r >> outLong;


        IT_r >> outFloat;


        IT_r >> outDouble;


        IT_r >> outChar;


        IT_r.decodeStringOp(outString);
        CORBA::Long IT_result;
        IT_r >> IT_result;
        IT_r.checkEnv (IT_env);
        IT_raise.maybeRaise ();
        return IT_result;
    }
    if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
        IT_r.checkEnv (IT_env);
    }
    IT_raise.maybeRaise ();
    return 0;
}

CORBA::Long TestReqReply:: test_struct_args (const PerfStruct& structVal, PerfStruct& inoutStruct, PerfStruct*& outStruct, CORBA::Environment &IT_env) throw (CORBA::SystemException) {

    CORBA::EnvExcRaiser IT_raise (&IT_env);
    if (IT_env || m_isNull) {
        IT_raise.maybeRaise ();
        return 0;
    }
    CORBA::Request IT_r (this, "test_struct_args",IT_env,1,0);
    if (!IT_r.isException (IT_env)) {

        structVal.encodeOp (IT_r);


        inoutStruct.encodeOp (IT_r);

    }

    IT_r.invoke (CORBA::Flags(0),IT_env);
    if (!IT_r.isException (IT_env)) {


        inoutStruct.decodeInOutOp (IT_r);

        outStruct = new PerfStruct;

        (*outStruct).decodeOp (IT_r);
        CORBA::Long IT_result;
        IT_r >> IT_result;
        IT_r.checkEnv (IT_env);
        IT_raise.maybeRaise ();
        return IT_result;
    }
    if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
        IT_r.checkEnv (IT_env);
    }
    IT_raise.maybeRaise ();
    return 0;
}

CORBA::Long TestReqReply:: test_prim_seq (const shortSeq& shortVal, const longSeq& longVal, const floatSeq& floatVal, const doubleSeq& doubleVal, const charSeq& charVal, const stringSeq& stringVal, shortSeq& inoutShort, longSeq& inoutLong, floatSeq& inoutFloat, doubleSeq& inoutDouble, charSeq& inoutChar, stringSeq& inoutString, shortSeq*& outShort, longSeq*& outLong, floatSeq*& outFloat, doubleSeq*& outDouble, charSeq*& outChar, stringSeq*& outString, CORBA::Environment &IT_env) throw (CORBA::SystemException) {

    CORBA::EnvExcRaiser IT_raise (&IT_env);
    if (IT_env || m_isNull) {
        IT_raise.maybeRaise ();
        return 0;
    }
    CORBA::Request IT_r (this, "test_prim_seq",IT_env,1,0);
    if (!IT_r.isException (IT_env)) {

        shortVal.encodeOp (IT_r);


        longVal.encodeOp (IT_r);


        floatVal.encodeOp (IT_r);


        doubleVal.encodeOp (IT_r);


        charVal.encodeOp (IT_r);


        stringVal.encodeOp (IT_r);


        inoutShort.encodeOp (IT_r);


        inoutLong.encodeOp (IT_r);


        inoutFloat.encodeOp (IT_r);


        inoutDouble.encodeOp (IT_r);


        inoutChar.encodeOp (IT_r);


        inoutString.encodeOp (IT_r);






    }

    IT_r.invoke (CORBA::Flags(0),IT_env);
    if (!IT_r.isException (IT_env)) {







        inoutShort.decodeInOutOp (IT_r);


        inoutLong.decodeInOutOp (IT_r);


        inoutFloat.decodeInOutOp (IT_r);


        inoutDouble.decodeInOutOp (IT_r);


        inoutChar.decodeInOutOp (IT_r);


        inoutString.decodeInOutOp (IT_r);

        outShort = new shortSeq;

        (*outShort).decodeOp (IT_r);

        outLong = new longSeq;

        (*outLong).decodeOp (IT_r);

        outFloat = new floatSeq;

        (*outFloat).decodeOp (IT_r);

        outDouble = new doubleSeq;

        (*outDouble).decodeOp (IT_r);

        outChar = new charSeq;

        (*outChar).decodeOp (IT_r);

        outString = new stringSeq;

        (*outString).decodeOp (IT_r);
        CORBA::Long IT_result;
        IT_r >> IT_result;
        IT_r.checkEnv (IT_env);
        IT_raise.maybeRaise ();
        return IT_result;
    }
    if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
        IT_r.checkEnv (IT_env);
    }
    IT_raise.maybeRaise ();
    return 0;
}

CORBA::Long TestReqReply:: test_struct_seq (const structSeq& structVal, structSeq& inoutStruct, structSeq*& outStruct, CORBA::Environment &IT_env) throw (CORBA::SystemException) {

    CORBA::EnvExcRaiser IT_raise (&IT_env);
    if (IT_env || m_isNull) {
        IT_raise.maybeRaise ();
        return 0;
    }
    CORBA::Request IT_r (this, "test_struct_seq",IT_env,1,0);
    if (!IT_r.isException (IT_env)) {

        structVal.encodeOp (IT_r);


        inoutStruct.encodeOp (IT_r);

    }

    IT_r.invoke (CORBA::Flags(0),IT_env);
    if (!IT_r.isException (IT_env)) {


        inoutStruct.decodeInOutOp (IT_r);

        outStruct = new structSeq;

        (*outStruct).decodeOp (IT_r);
        CORBA::Long IT_result;
        IT_r >> IT_result;
        IT_r.checkEnv (IT_env);
        IT_raise.maybeRaise ();
        return IT_result;
    }
    if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
        IT_r.checkEnv (IT_env);
    }
    IT_raise.maybeRaise ();
    return 0;
}

CORBA::Long TestReqReply:: test_struct_array (const structArray structVal, structArray inoutStruct, structArray_slice*& outStruct, CORBA::Environment &IT_env) throw (CORBA::SystemException) {

    CORBA::EnvExcRaiser IT_raise (&IT_env);
    if (IT_env || m_isNull) {
        IT_raise.maybeRaise ();
        return 0;
    }
    CORBA::Request IT_r (this, "test_struct_array",IT_env,1,0);
    if (!IT_r.isException (IT_env)) {
        if (!structVal) {
            IT_r.makeRuntimeException5 ();
            return 0;
        }
        else


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

        if (!inoutStruct) {
            IT_r.makeRuntimeException5 ();
            return 0;
        }
        else


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

    }

    IT_r.invoke (CORBA::Flags(0),IT_env);
    if (!IT_r.isException (IT_env)) {



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

        outStruct = new structArray;


        {
            PerfStruct* IT_elem = (PerfStruct*) outStruct;
            for (unsigned long i3 = 0; i3 < 100; i3++, IT_elem++)
            IT_elem->decodeOp (IT_r);
        }
        CORBA::Long IT_result;
        IT_r >> IT_result;
        IT_r.checkEnv (IT_env);
        IT_raise.maybeRaise ();
        return IT_result;
    }
    if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
        IT_r.checkEnv (IT_env);
    }
    IT_raise.maybeRaise ();
    return 0;
}


TestReqReplyProxyFactoryClass TestReqReplyProxyFactory(1);


#ifndef TestReqReply_dispatch_impl

unsigned char TestReqReply_dispatch::dispatch (CORBA::Request &IT_r, 
    unsigned char, void *) {
      IT_r.makeRuntimeException1 ("TestReqReply");
      return 0;
}
 
#endif

TestOneway_dkv::TestOneway_dkv (char *IT_OR) {
      m_pptr = new TestOneway_dkv_dispatch (IT_OR, this,(CORBA::Object*)this);
} 
TestOneway_dkv::TestOneway_dkv (ObjectReference *IT_OR) {
      m_pptr = new TestOneway_dkv_dispatch (IT_OR, this,(CORBA::Object*)this);
} 

#ifndef TestOneway_dkvForwC
#define TestOneway_dkvForwC
CORBA::ObjectRef TestOneway_dkv_getBase(void *IT_p){
    return (TestOneway_dkv*) IT_p;}

void TestOneway_dkv_release (TestOneway_dkv_ptr IT_p, CORBA::Environment &IT_env) {
    CORBA::release(IT_p, IT_env);}

void TestOneway_dkv_release (TestOneway_dkv_ptr IT_p) {
    TestOneway_dkv_release (IT_p, CORBA::IT_chooseDefaultEnv ()); }

TestOneway_dkv_ptr TestOneway_dkv_nil (CORBA::Environment &) {
    return TestOneway_dkv:: _nil ();}

TestOneway_dkv_ptr TestOneway_dkv_nil () {
    return TestOneway_dkv_nil (CORBA::IT_chooseDefaultEnv ());}

TestOneway_dkv_ptr TestOneway_dkv_duplicate (TestOneway_dkv_ptr IT_p, CORBA::Environment &IT_env) {
    return (TestOneway_dkv::_duplicate(IT_p, IT_env)); }
TestOneway_dkv_ptr TestOneway_dkv_duplicate (TestOneway_dkv_ptr IT_p) {
    return TestOneway_dkv_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); }
#endif



TestOneway_dkv* TestOneway_dkv:: _bind (const char* IT_markerServer, const char* host,
		const CORBA::Context &IT_c, 
		CORBA::Environment &IT_env) {
       return (TestOneway_dkv*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, 
		TestOneway_dkv_IMPL, TestOneway_dkv_IR);
}



TestOneway_dkv* TestOneway_dkv:: _bind (CORBA::Environment &IT_env) {
       return _bind (NULL,NULL,CORBA::Context(), IT_env); }


TestOneway_dkv* TestOneway_dkv:: _bind (const char* IT_markerServer, const char* host,
                CORBA::Environment &IT_env) {
       return _bind (IT_markerServer, host, CORBA::Context (), IT_env); }
TestOneway_dkv* TestOneway_dkv::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_env) {
       CORBA::EnvExcRaiser IT_raise (&IT_env);
        if (CORBA::is_nil (IT_obj)) {
                IT_raise.maybeRaise();
                return TestOneway_dkv:: _nil();
        }

       TestOneway_dkv* IT_p = (TestOneway_dkv*)CORBA::Object::_castDown (IT_obj, TestOneway_dkv_IR, IT_env);
        IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL;
        if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) {
                IT_env.exception_free();
        }
        IT_raise.maybeRaise();
        return IT_p;
   }

void* TestOneway_dkvProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) {
        return  new class TestOneway_dkv(IT_OR);}

void* TestOneway_dkvProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) {
        return  new class TestOneway_dkv(IT_OR);}

void* TestOneway_dkvProxyFactoryClass::New2 () {
        return  new class TestOneway_dkv();}

void* TestOneway_dkvProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s) {
      void *IT_l;
      if (!CORBA::_interfaceCmp (IT_s,TestOneway_dkv_IR))
         return IT_p;
      else if (IT_l=TestOnewayProxyFactoryClass::IT_castUp((class TestOneway*)((class TestOneway_dkv*)IT_p),IT_s))
          return IT_l;
      else return NULL;
    }


CORBA::PPTR* TestOneway_dkvProxyFactoryClass::pptr (void *IT_p) {
       return ((class TestOneway_dkv*)IT_p)->_pptr ();}

void TestOneway_dkvProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) {
      add (seq, TestOneway_dkv_IR);
      TestOnewayProxyFactoryClass::baseInterfaces (seq);
}


TestOneway_dkvProxyFactoryClass TestOneway_dkvProxyFactory(1);


#ifndef TestOneway_dkv_dispatch_impl

unsigned char TestOneway_dkv_dispatch::dispatch (CORBA::Request &IT_r, 
    unsigned char, void *) {
      IT_r.makeRuntimeException1 ("TestOneway_dkv");
      return 0;
}
 
#endif