xmog_request.h

Go to the documentation of this file.

//
// Copyright (c) 1999-2020 by Codemesh, Inc.. ALL RIGHTS RESERVED.
//
 
// -*- C++ -*-
 
 
//==========================================================================
//==========================================================================
 
#ifndef xmog_request_inc
#define xmog_request_inc
 
class ACE_Message_Block;
#include "ace/Basic_Types.h"
#include "ace/Future.h"
#include "ace/Method_Request.h"
#include "ace/Time_Value.h"
 
#include "xmog.h"
#include "xmog_JavaVM.h"
#include "xmog_JNIEnv.h"
#include "xmog_message_types.h"
#include "xmog_reply.h"
 
 
struct xmog_base;
 
 
class xmog_request
{
public:
 
  enum { INIT_BLOCK_SIZE = 4096 };
 
  explicit xmog_request (xmog::xmog_message_id reqtype,
                         const void *orig = 0,
                         bool reply_expected = true);
  ~xmog_request ();
 
  void  dump();
 
  xmog::xmog_message_id type (void) const;
 
  ACE_Future<xmog_reply*> &reply (void);
 
  ACE_Message_Block *block (void) const;
 
  const void *originator (void) const;
 
  void expires (const ACE_Time_Value &expiration);
 
  bool expired (const ACE_Time_Value &now) const;
 
  void complete (xmog_reply *reply);
 
  bool reply_expected (void) const;
 
    int writeBoolean( bool b );
 
    int writeByte( jbyte b );
 
    int writeChar( jchar c );
 
    int writeDouble( jdouble d );
 
    int writeFloat( jfloat d );
 
    int writeInt( jint i );
 
    int writeShort( jshort s );
 
    int writeLong( jlong l );
 
    int writeDataCode( xmog::xmog_data_code code, int align = 4 );
 
    int writeDataBoolean( bool b );
 
    int writeDataByte( jbyte b );
 
    int writeDataChar( jchar ch );
 
    int writeDataDouble( jdouble d );
 
    int writeDataFloat( jfloat f );
 
    int writeDataInt( jint i );
 
    int writeDataLong( jlong l );
 
    int writeDataShort( jshort s );
 
    int writeDataNull( int align );
 
    int writeDataProxy( xmog_base * obj, int align, xmog_localenv * env = NULL );
 
    int writeEncodedDataString( xmog_remote_java_value & data );
 
    int writeDataStringUtf( const char * str, size_t len = (size_t)-1 );
 
    int writeDataStringUtf16( const unsigned short * str, size_t len = (size_t)-1 );
 
    int writeString( const char * str, size_t len = (size_t)-1 );
 
    int writeString( const XMOG_WCHAR * str, size_t len = (size_t)-1 );
 
    int writeUTF( const char * utf, size_t len = (size_t)-1 );
 
    int writeParameter( const xmog_remote_java_value & val, int align, int & cbAdded );
 
private:
 
    xmog::xmog_message_id type_;
    const void *originator_;
 
protected:
 
    ACE_Message_Block *block_;
 
private:
 
    ACE_Time_Value expires_;        // Abs time at which the request times out
    ACE_Future<xmog_reply*> reply_;
    bool reply_expected_;
};
 
 
 
class xmog_request_sign_on : public xmog_request
{
public:
  xmog_request_sign_on () : xmog_request (xmog::SIGN_ON, 0) {}
 
  int add_args (const void *jvm_p,
                int authType,
                int stringCopyLimit,
                int primArrayCopyLimit,
                bool maintainObjID,
                bool sendStringOnFirstRef,
                bool alignDataForClient,
                const char *clientSignOnNameUTF,
                const char *clientCredentialsUTF,
                const char *clientDisplayNameUTF,
                const char *serverAppNameUTF);
};
 
class xmog_request_thread_id_request : public xmog_request
{
public:
  xmog_request_thread_id_request (const void *originator)
    : xmog_request (xmog::THREAD_ID_REQUEST, originator) {}
 
  int add_args (int fake_thread_id,
                const JavaVMAttachArgs *args,
                bool daemon);
};
 
class xmog_request_thread_terminated : public xmog_request
{
public:
  xmog_request_thread_terminated (const void *originator)
    : xmog_request (xmog::THREAD_TERMINATED, originator, false) {}
 
  int add_args (int threadId, const char *threadName = 0);
};
 
class xmog_request_session_terminated : public xmog_request
{
public:
  xmog_request_session_terminated ()
    : xmog_request (xmog::SESSION_TERMINATED, 0, false) {}
};
 
class xmog_request_member_ids_request : public xmog_request
{
public:
  xmog_request_member_ids_request (const void *originator)
    : xmog_request (xmog::MEMBER_IDS_REQUEST, originator) {}
 
  int add_args (int threadID, int classID, const char *className, int numMembers = 0, ... /* member names */);
};
 
class xmog_request_class_info : public xmog_request
{
public:
  xmog_request_class_info (const void *originator)
      : xmog_request (xmog::CLASS_INFO_REQUEST, originator) {}
 
  int add_args (int threadID, int classID );
};
 
class xmog_request_drop_refs : public xmog_request
{
public:
  xmog_request_drop_refs (const void *originator)
    : xmog_request (xmog::DROP_OBJECT_REFS, originator, false) {}
 
  int add_args( int threadID, int numRefs, jint * pIdsCounts );
 
  int add_args( int threadID, jint id, jint count );
};
 
class xmog_request_field_get : public xmog_request
{
public:
  xmog_request_field_get (const void *originator)
      : xmog_request (xmog::GET_FIELD_REQUEST, originator) {}
 
  int add_args (int threadID, 
                int classID,
                int fieldID,
                bool bLimitReturnValueCopying = true,
                xmog_base * target = NULL );
};
 
class xmog_request_field_set : public xmog_request
{
public:
  xmog_request_field_set (const void *originator)
      : xmog_request (xmog::SET_FIELD_REQUEST, originator) {}
 
  int add_args (int threadID, 
                int classID,
                int fieldID,
                xmog_base * target,
                const xmog_remote_java_value & val,
                xmog_localenv * env );
};
 
class xmog_request_method_call : public xmog_request
{
public:
 
    xmog_request_method_call (const void *originator)
    : xmog_request (xmog::METHOD_CALL, originator),
      pDataLengthOffset( 0 ),
      pNumArgumentsOffset( 0 ),
      numArgs( 0 ) {}
 
    int add_args (  int threadID, 
                    xmog_JNIEnv * env, 
                    int classID,
                    int methodID,
                    bool bLimitReturnValueCopying,
                    xmog_base * target );
  
    int add_param( const xmog_remote_java_value & param, int & cbAdded );
 
private:
 
    jint            pDataLengthOffset;
    jint            pNumArgumentsOffset;
    int             numArgs;
};
 
class xmog_request_ctor_call : public xmog_request
{
public:
 
    xmog_request_ctor_call (const void *originator)
    : xmog_request (xmog::CONSTRUCTOR_CALL, originator),
      pDataLengthOffset( 0 ),
      pNumArgumentsOffset( 0 ),
      numArgs( 0 ) {}
 
    int add_args (  int threadID, 
                    xmog_JNIEnv * env, 
                    int classID,
                    int methodID );
  
    int add_param( const xmog_remote_java_value & param, int & cbAdded );
 
private:
 
    jint            pDataLengthOffset;
    jint            pNumArgumentsOffset;
    int             numArgs;
};
#endif /* __XMOG_REQUEST_H */