xmog_reply.h

Go to the documentation of this file.

//
// Copyright (c) 1999-2020 by Codemesh, Inc.. ALL RIGHTS RESERVED.
//
 
// -*- C++ -*-
 
//==========================================================================
//==========================================================================
 
#ifndef __XMOG_REPLY_H
#define __XMOG_REPLY_H
 
class ACE_Message_Block;
#include "ace/Basic_Types.h"
 
#include "xmog.h"
#include "xmog_util.h"
#include "xmog_java_value.h"
#include "xmog_message_types.h"
 
class xmog_request;
 
 
class xmog_reply
{
public:
 
  static xmog_reply *decode (ACE_Message_Block *b);
 
  typedef enum { SUCCESS = 1, TIMEOUT, COMM_FAILURE } Disposition;
 
  enum { INIT_BLOCK_SIZE = 4096 };
 
  xmog_reply (Disposition disp,
              xmog::xmog_message_id t = xmog::NONE,
              ACE_Message_Block *b = 0);
  xmog_reply (const xmog_reply &r);
  xmog_reply &operator= (const xmog_reply &r);
 
  virtual ~xmog_reply ();
 
  Disposition disposition (void) const;
 
  xmog::xmog_message_id type (void) const;
 
  virtual bool matches (const xmog_request *req) const;
 
  void  dump();
 
protected:
  virtual bool unmarshal (void) { return false; }  // Reimplement this
 
    int readBoolean( bool &b );
 
    int readByte( jbyte &b);
 
    int readChar( jchar &c );
 
    int readDouble( jdouble &d );
 
    int readFloat ( jfloat &f );
 
    int readInt( jint &i );
 
    int readShort( jshort &s );
 
    int readLong( jlong &l );
 
    int readClassName( char ** str );
 
    int readUTF( char ** str, jint * len = NULL );
 
    int readLongUTF( char ** str, jint * len = NULL );
 
    int readStringProxy( xmog_remote_java_value & data, xmog::xmog_data_code code );
 
    int read_data_code( xmog::xmog_data_code & code );
 
    int readData( xmog_remote_java_value & data );
 
    int readExc( xmog_remote_java_exception & data );
 
    int readDataProxy( xmog_remote_java_value & data );
 
private:
  xmog_reply () {};          // Must supply at least the type
 
  Disposition disp_;
  xmog::xmog_message_id type_;
  ACE_Message_Block *b_;
};
 
// Now declare the individual reply types, reimplementing anything needed.
// All the subtypes need to reimplement unmarshal() since it's pure virtual
// in xmog_reply.
 
class xmog_reply_sign_on_status : public xmog_reply
{
public:
  enum sign_on_status {
    STATUS_OK = 0,
    STATUS_NO_NEW_SESSIONS = 1,
    STATUS_NOT_AUTHORIZED = 2,
    STATUS_SHUTTING_DOWN = 3,
    STATUS_UNSUPPORTED_PROTOCOL = 4
  };
 
  xmog_reply_sign_on_status (ACE_Message_Block *b)
    : xmog_reply (xmog_reply::SUCCESS, xmog::SIGN_ON_STATUS, b) {}
 
  sign_on_status status (void) const;
 
  jint  RemoteStringUtilsId() const;
 
  jint  ObjectId() const;
 
  jint  ClassId() const;
 
  jint  ThrowableId() const;
 
  jint  ExceptionId() const;
 
  jint  StringId() const;
 
protected:
  virtual bool unmarshal (void);
 
private:
  sign_on_status status_;
  jint jni_version_;
  jint clsRemoteStringUtils_;
  jint clsObject_;
  jint clsClass_;
  jint clsThrowable_;
  jint clsException_;
  jint clsString_;
  jbyte required_major_version_;
};
 
 
class xmog_reply_thread_id_assignment : public xmog_reply
{
public:
  xmog_reply_thread_id_assignment (ACE_Message_Block *b)
    : xmog_reply (xmog_reply::SUCCESS, xmog::THREAD_ID_ASSIGNMENT, b) {}
 
  jint assigned_thread_id (void) const { return this->assigned_thread_id_; }
  void *originator (void) const { return this->originator_; }
      bool matches (const xmog_request *req) const;
 
protected:
  virtual bool unmarshal (void);
 
private:
  jint thread_id_;
  void *originator_;
  jint assigned_thread_id_;
};
 
 
class xmog_reply_member_ids_assignment : public xmog_reply
{
public:
  xmog_reply_member_ids_assignment (ACE_Message_Block *b)
    : xmog_reply (xmog_reply::SUCCESS, xmog::MEMBER_IDS_ASSIGNMENT, b),
      memberIds_( 0 ) {}
 
  jclass getClassId (void) const { return this->class_id_; }
  jsize getNumMembers() const { return this->numMembers_; }
  jint  getMemberId( size_t index ) const { return memberIds_[ index ]; }
  void *originator (void) const { return this->originator_; }
      bool matches (const xmog_request *req) const;
 
  ~xmog_reply_member_ids_assignment();
 
protected:
  virtual bool unmarshal (void);
 
private:
  void *originator_;
  jclass class_id_;
  jsize numMembers_;
  jint * memberIds_;
};
 
 
class class_info
{
    jint        id_;
    char *      name_;
    jint        super_;
    jsize       numIfcs_;
    jint *      ifcs_;
 
    class_info( const class_info & );
    class_info & operator = ( const class_info & );
 
public:
 
    class_info() : name_( 0 ), ifcs_( 0 ) {}
    ~class_info() { if( ifcs_ ) delete ifcs_; xmog_util::setString( name_, 0 ); }
    void   set_class( jint id ) { id_ = id; }
    jint   get_class() const { return id_; }
    void   set_class_name( char * name ) { xmog_util::setString( name_, name ); }
    char * get_class_name() const { return name_; }
    void   set_super( jint id ) { super_ = id; }
    jint   get_super() const { return super_; }
    void   set_num_ifcs( jint num ) { numIfcs_ = num; ifcs_ = new jint[ numIfcs_ ]; }
    jsize  get_num_ifcs() const { return numIfcs_; }
    void   set_ifc( int index, jint id ) { ifcs_[ index ] = id; }
    jint   get_ifc( int index ) const { return ifcs_[ index ]; }
 
};
 
 
class xmog_reply_class_info : public xmog_reply
{
public:
  xmog_reply_class_info (ACE_Message_Block *b)
      : xmog_reply (xmog_reply::SUCCESS, xmog::CLASS_INFO_RESPONSE, b),
      infos_( 0 ) {}
 
  jsize getNumInfos() const { return this->numInfos_; }
  class_info &  getInfo( size_t index ) const { return infos_[ index ]; }
  void *originator (void) const { return this->originator_; }
      bool matches (const xmog_request *req) const;
 
  ~xmog_reply_class_info();
 
protected:
  virtual bool unmarshal (void);
 
private:
  void *originator_;
  jsize numInfos_;
  class_info * infos_;
};
 
class xmog_reply_field_get : public xmog_reply
{
public:
    xmog_reply_field_get( ACE_Message_Block *b )
      : xmog_reply (xmog_reply::SUCCESS, xmog::GET_FIELD_RESPONSE, b) {}
 
      void *                                originator (void) const { return this->originator_; }
      xmog_remote_java_value &              getData() { return data_; }
      const xmog_remote_java_exception &    getExc() const { return exc_; }
      jlong getException() const { return (jlong)exc_.exc_; }
      bool matches (const xmog_request *req) const;
 
protected:
    virtual bool unmarshal (void);
 
private:
    jint thread_id_;
    void *originator_;
    xmog_remote_java_value      data_;
    xmog_remote_java_exception  exc_;
};
 
 
class xmog_reply_field_set : public xmog_reply
{
public:
    xmog_reply_field_set( ACE_Message_Block *b )
      : xmog_reply (xmog_reply::SUCCESS, xmog::SET_FIELD_RESPONSE, b) {}
 
      void *                                originator (void) const { return this->originator_; }
      jlong     getException() const { return (jlong)exc_.exc_; }
      const xmog_remote_java_exception &    getExc() const { return exc_; }
      bool matches (const xmog_request *req) const;
 
protected:
    virtual bool unmarshal (void);
 
private:
    jint thread_id_;
    void *originator_;
    xmog_remote_java_value      data_;
    xmog_remote_java_exception  exc_;
};
 
 
class xmog_reply_method_call : public xmog_reply
{
public:
    xmog_reply_method_call( ACE_Message_Block *b )
      : xmog_reply (xmog_reply::SUCCESS, xmog::METHOD_RETURN, b) {}
 
      jint                                  thread_id() const { return thread_id_; }
      void *                                originator (void) const { return this->originator_; }
      xmog_remote_java_value &              getData() { return data_; }
      const xmog_remote_java_exception &    getExc() const { return exc_; }
      jlong     getException() const { return (jlong)exc_.exc_; }
      bool matches (const xmog_request *req) const;
 
protected:
    virtual bool unmarshal (void);
 
private:
    jint thread_id_;
    void *originator_;
    xmog_remote_java_value      data_;
    xmog_remote_java_exception  exc_;
};
 
 
class xmog_reply_ctor_call : public xmog_reply
{
public:
    xmog_reply_ctor_call( ACE_Message_Block *b )
    : xmog_reply (xmog_reply::SUCCESS, xmog::CONSTRUCTOR_RETURN, b) {}
 
      jint                                  thread_id() const { return thread_id_; }
      void *                                originator (void) const { return this->originator_; }
      const xmog_remote_java_value &        getData() const { return data_; }
      const xmog_remote_java_exception &    getExc() const { return exc_; }
      jlong     getException() const { return (jlong)exc_.exc_; }
      bool matches (const xmog_request *req) const;
 
protected:
    virtual bool unmarshal (void);
 
private:
    jint thread_id_;
    void *originator_;
    xmog_remote_java_value      data_;
    xmog_remote_java_exception  exc_;
};
 
#endif /* __XMOG_REPLY_H */