Logo Search packages:      
Sourcecode: sanduhr version File versions  Download package

sanduhr-skels.c

/*
 * This file was generated by orbit-idl - DO NOT EDIT!
 */

#include <string.h>
#include "sanduhr.h"

void
_ORBIT_SandUhr_AlarmAction_DeliveryFailed_marshal(GIOPSendBuffer *
                                      _ORBIT_send_buffer,
                                      CORBA_Environment * ev)
{
   register CORBA_unsigned_long _ORBIT_tmpvar_0;
   CORBA_unsigned_long _ORBIT_tmpvar_1;
   SandUhr_AlarmAction_DeliveryFailed *_ORBIT_exdata = ev->_params;

   _ORBIT_tmpvar_1 = strlen((*_ORBIT_exdata).Reason) + 1;
   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
                            4);
   giop_send_buffer_append_mem_indirect(GIOP_SEND_BUFFER(_ORBIT_send_buffer),
                              &(_ORBIT_tmpvar_1),
                              sizeof(_ORBIT_tmpvar_1));
   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
                          ((*_ORBIT_exdata).Reason),
                          sizeof((*_ORBIT_exdata).
                               Reason[_ORBIT_tmpvar_0]) *
                          _ORBIT_tmpvar_1);
}

void
_ORBIT_skel_SandUhr_AlarmAction__get_NeedsPopup(POA_SandUhr_AlarmAction *
                                    _ORBIT_servant,
                                    GIOPRecvBuffer *
                                    _ORBIT_recv_buffer,
                                    CORBA_Environment * ev,
                                    CORBA_boolean
                                    (*_impl__get_NeedsPopup)
                                    (PortableServer_Servant
                                     _servant,
                                     CORBA_Environment * ev))
{
   CORBA_boolean _ORBIT_retval;

   _ORBIT_retval = _impl__get_NeedsPopup(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_AlarmAction_Attach(POA_SandUhr_AlarmAction *
                               _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl_Attach)
                               (PortableServer_Servant _servant,
                              const SandUhr_Timer T,
                              CORBA_Environment * ev))
{
   SandUhr_Timer T;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
       T = ORBit_demarshal_object(_ORBIT_recv_buffer,
                            (((ORBit_ObjectKey *) _ORBIT_servant->
                              _private)->object->orb));
       _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
       GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
       T = ORBit_demarshal_object(_ORBIT_recv_buffer,
                            (((ORBit_ObjectKey *) _ORBIT_servant->
                              _private)->object->orb));
       _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
   }
   _impl_Attach(_ORBIT_servant, T, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      CORBA_Object_release((CORBA_Object) T, ev);
   }
}
void
_ORBIT_skel_SandUhr_AlarmAction_Detach(POA_SandUhr_AlarmAction *
                               _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl_Detach)
                               (PortableServer_Servant _servant,
                              const SandUhr_Timer T,
                              CORBA_Environment * ev))
{
   SandUhr_Timer T;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
       T = ORBit_demarshal_object(_ORBIT_recv_buffer,
                            (((ORBit_ObjectKey *) _ORBIT_servant->
                              _private)->object->orb));
       _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
       GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
       T = ORBit_demarshal_object(_ORBIT_recv_buffer,
                            (((ORBit_ObjectKey *) _ORBIT_servant->
                              _private)->object->orb));
       _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
   }
   _impl_Detach(_ORBIT_servant, T, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      CORBA_Object_release((CORBA_Object) T, ev);
   }
}
void
_ORBIT_skel_SandUhr_AlarmAction_Deliver(POA_SandUhr_AlarmAction *
                              _ORBIT_servant,
                              GIOPRecvBuffer * _ORBIT_recv_buffer,
                              CORBA_Environment * ev,
                              void (*_impl_Deliver)
                              (PortableServer_Servant _servant,
                               const CORBA_char * TimeSpec,
                               const CORBA_char * Message,
                               CORBA_Environment * ev))
{
   CORBA_char *TimeSpec;
   CORBA_char *Message;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_4;
      CORBA_unsigned_long _ORBIT_tmpvar_5;
      register CORBA_unsigned_long _ORBIT_tmpvar_6;
      CORBA_unsigned_long _ORBIT_tmpvar_7;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_5))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       TimeSpec = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(TimeSpec[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_7))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       Message = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(Message[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_5 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       TimeSpec = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(TimeSpec[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_7 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       Message = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(Message[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7;
      }
   }
   _impl_Deliver(_ORBIT_servant, TimeSpec, Message, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode)
              &TC_SandUhr_AlarmAction_DeliveryFailed_struct,
              (gpointer)
              _ORBIT_SandUhr_AlarmAction_DeliveryFailed_marshal},
             {CORBA_OBJECT_NIL, NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_AlarmBeep__get_Count(POA_SandUhr_AlarmBeep *
                               _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               CORBA_unsigned_short
                               (*_impl__get_Count)
                               (PortableServer_Servant _servant,
                                CORBA_Environment * ev))
{
   CORBA_unsigned_short _ORBIT_retval;

   _ORBIT_retval = _impl__get_Count(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 2);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_AlarmBeep__set_Count(POA_SandUhr_AlarmBeep *
                               _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl__set_Count)
                               (PortableServer_Servant _servant,
                                const CORBA_unsigned_short value,
                                CORBA_Environment * ev))
{
   CORBA_unsigned_short value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
       (*((guint16 *) & (value))) =
          GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
       value = *((CORBA_unsigned_short *) _ORBIT_curptr);
      }
   }
   _impl__set_Count(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_AlarmSound__get_SoundFile(POA_SandUhr_AlarmSound *
                                    _ORBIT_servant,
                                    GIOPRecvBuffer *
                                    _ORBIT_recv_buffer,
                                    CORBA_Environment * ev,
                                    CORBA_char *
                                    (*_impl__get_SoundFile)
                                    (PortableServer_Servant
                                     _servant,
                                     CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;

   _ORBIT_retval = _impl__get_SoundFile(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          CORBA_unsigned_long _ORBIT_tmpvar_1;

          _ORBIT_tmpvar_1 = strlen(_ORBIT_retval) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_1));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (_ORBIT_retval),
                                 sizeof(_ORBIT_retval
                                      [_ORBIT_tmpvar_0]) *
                                 _ORBIT_tmpvar_1);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_SandUhr_AlarmSound__set_SoundFile(POA_SandUhr_AlarmSound *
                                    _ORBIT_servant,
                                    GIOPRecvBuffer *
                                    _ORBIT_recv_buffer,
                                    CORBA_Environment * ev,
                                    void (*_impl__set_SoundFile)
                                    (PortableServer_Servant
                                     _servant,
                                     const CORBA_char * value,
                                     CORBA_Environment * ev))
{
   CORBA_char *value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl__set_SoundFile(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_AlarmCommand__get_CommandString(POA_SandUhr_AlarmCommand *
                                        _ORBIT_servant,
                                        GIOPRecvBuffer *
                                        _ORBIT_recv_buffer,
                                        CORBA_Environment * ev,
                                        CORBA_char *
                                        (*_impl__get_CommandString)
                                        (PortableServer_Servant
                                         _servant,
                                         CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;

   _ORBIT_retval = _impl__get_CommandString(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          CORBA_unsigned_long _ORBIT_tmpvar_1;

          _ORBIT_tmpvar_1 = strlen(_ORBIT_retval) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_1));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (_ORBIT_retval),
                                 sizeof(_ORBIT_retval
                                      [_ORBIT_tmpvar_0]) *
                                 _ORBIT_tmpvar_1);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_SandUhr_AlarmCommand__set_CommandString(POA_SandUhr_AlarmCommand *
                                        _ORBIT_servant,
                                        GIOPRecvBuffer *
                                        _ORBIT_recv_buffer,
                                        CORBA_Environment * ev,
                                        void
                                        (*_impl__set_CommandString)
                                        (PortableServer_Servant
                                         _servant,
                                         const CORBA_char * value,
                                         CORBA_Environment * ev))
{
   CORBA_char *value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl__set_CommandString(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_SandUhr_Timer_NotRunning_marshal(GIOPSendBuffer * _ORBIT_send_buffer,
                              CORBA_Environment * ev)
{
}
void
_ORBIT_skel_SandUhr_Timer__get_State(POA_SandUhr_Timer * _ORBIT_servant,
                             GIOPRecvBuffer * _ORBIT_recv_buffer,
                             CORBA_Environment * ev,
                             SandUhr_Timer_TimerState
                             (*_impl__get_State)
                             (PortableServer_Servant _servant,
                              CORBA_Environment * ev))
{
   SandUhr_Timer_TimerState _ORBIT_retval;

   _ORBIT_retval = _impl__get_State(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__get_TimeSpec(POA_SandUhr_Timer * _ORBIT_servant,
                              GIOPRecvBuffer * _ORBIT_recv_buffer,
                              CORBA_Environment * ev,
                              CORBA_char *
                              (*_impl__get_TimeSpec)
                              (PortableServer_Servant _servant,
                               CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;

   _ORBIT_retval = _impl__get_TimeSpec(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          CORBA_unsigned_long _ORBIT_tmpvar_1;

          _ORBIT_tmpvar_1 = strlen(_ORBIT_retval) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_1));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (_ORBIT_retval),
                                 sizeof(_ORBIT_retval
                                      [_ORBIT_tmpvar_0]) *
                                 _ORBIT_tmpvar_1);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_SandUhr_Timer__set_TimeSpec(POA_SandUhr_Timer * _ORBIT_servant,
                              GIOPRecvBuffer * _ORBIT_recv_buffer,
                              CORBA_Environment * ev,
                              void (*_impl__set_TimeSpec)
                              (PortableServer_Servant _servant,
                               const CORBA_char * value,
                               CORBA_Environment * ev))
{
   CORBA_char *value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl__set_TimeSpec(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__get_Message(POA_SandUhr_Timer * _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               CORBA_char *
                               (*_impl__get_Message)
                               (PortableServer_Servant _servant,
                              CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;

   _ORBIT_retval = _impl__get_Message(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          CORBA_unsigned_long _ORBIT_tmpvar_1;

          _ORBIT_tmpvar_1 = strlen(_ORBIT_retval) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_1));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (_ORBIT_retval),
                                 sizeof(_ORBIT_retval
                                      [_ORBIT_tmpvar_0]) *
                                 _ORBIT_tmpvar_1);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_SandUhr_Timer__set_Message(POA_SandUhr_Timer * _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl__set_Message)
                               (PortableServer_Servant _servant,
                              const CORBA_char * value,
                              CORBA_Environment * ev))
{
   CORBA_char *value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       value = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl__set_Message(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__get_Alarm(POA_SandUhr_Timer * _ORBIT_servant,
                             GIOPRecvBuffer * _ORBIT_recv_buffer,
                             CORBA_Environment * ev,
                             SandUhr_AlarmAction(*_impl__get_Alarm)
                             (PortableServer_Servant _servant,
                              CORBA_Environment * ev))
{
   SandUhr_AlarmAction _ORBIT_retval;

   _ORBIT_retval = _impl__get_Alarm(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_SandUhr_Timer__set_Alarm(POA_SandUhr_Timer * _ORBIT_servant,
                             GIOPRecvBuffer * _ORBIT_recv_buffer,
                             CORBA_Environment * ev,
                             void (*_impl__set_Alarm)
                             (PortableServer_Servant _servant,
                              const SandUhr_AlarmAction value,
                              CORBA_Environment * ev))
{
   SandUhr_AlarmAction value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
       value =
          ORBit_demarshal_object(_ORBIT_recv_buffer,
                           (((ORBit_ObjectKey *) _ORBIT_servant->
                             _private)->object->orb));
       _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
       GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
       value =
          ORBit_demarshal_object(_ORBIT_recv_buffer,
                           (((ORBit_ObjectKey *) _ORBIT_servant->
                             _private)->object->orb));
       _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
   }
   _impl__set_Alarm(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      CORBA_Object_release((CORBA_Object) value, ev);
   }
}
void
_ORBIT_skel_SandUhr_Timer__get_SandColor(POA_SandUhr_Timer * _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               SandUhr_Timer_Color
                               (*_impl__get_SandColor)
                               (PortableServer_Servant _servant,
                                CORBA_Environment * ev))
{
   SandUhr_Timer_Color _ORBIT_retval;

   _ORBIT_retval = _impl__get_SandColor(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 2);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__set_SandColor(POA_SandUhr_Timer * _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl__set_SandColor)
                               (PortableServer_Servant _servant,
                                const SandUhr_Timer_Color * value,
                                CORBA_Environment * ev))
{
   SandUhr_Timer_Color value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
       (*((guint16 *) & (value.Red))) =
          GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
       _ORBIT_curptr += 2;
       (*((guint16 *) & (value.Green))) =
          GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
       _ORBIT_curptr += 2;
       (*((guint16 *) & (value.Blue))) =
          GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
       memcpy(&(value), _ORBIT_curptr, sizeof(value));
      }
   }
   _impl__set_SandColor(_ORBIT_servant, &(value), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__get_WindowDecorations(POA_SandUhr_Timer *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     CORBA_boolean
                                     (*_impl__get_WindowDecorations)
                                     (PortableServer_Servant
                                      _servant,
                                      CORBA_Environment * ev))
{
   CORBA_boolean _ORBIT_retval;

   _ORBIT_retval = _impl__get_WindowDecorations(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__set_WindowDecorations(POA_SandUhr_Timer *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     void
                                     (*_impl__set_WindowDecorations)
                                     (PortableServer_Servant
                                      _servant,
                                      const CORBA_boolean value,
                                      CORBA_Environment * ev))
{
   CORBA_boolean value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       value = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
       value = *((CORBA_boolean *) _ORBIT_curptr);
      }
   }
   _impl__set_WindowDecorations(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__get_WindowLayer(POA_SandUhr_Timer * _ORBIT_servant,
                                 GIOPRecvBuffer *
                                 _ORBIT_recv_buffer,
                                 CORBA_Environment * ev,
                                 SandUhr_Timer_Layer
                                 (*_impl__get_WindowLayer)
                                 (PortableServer_Servant _servant,
                                  CORBA_Environment * ev))
{
   SandUhr_Timer_Layer _ORBIT_retval;

   _ORBIT_retval = _impl__get_WindowLayer(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer__set_WindowLayer(POA_SandUhr_Timer * _ORBIT_servant,
                                 GIOPRecvBuffer *
                                 _ORBIT_recv_buffer,
                                 CORBA_Environment * ev,
                                 void (*_impl__set_WindowLayer)
                                 (PortableServer_Servant _servant,
                                  const SandUhr_Timer_Layer value,
                                  CORBA_Environment * ev))
{
   SandUhr_Timer_Layer value;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (value))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       value = *((SandUhr_Timer_Layer *) _ORBIT_curptr);
      }
   }
   _impl__set_WindowLayer(_ORBIT_servant, value, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer_Destroy(POA_SandUhr_Timer * _ORBIT_servant,
                          GIOPRecvBuffer * _ORBIT_recv_buffer,
                          CORBA_Environment * ev,
                          void (*_impl_Destroy)
                          (PortableServer_Servant _servant,
                           CORBA_Environment * ev))
{
   _impl_Destroy(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_SandUhr_Timer_TimeLeft(POA_SandUhr_Timer * _ORBIT_servant,
                           GIOPRecvBuffer * _ORBIT_recv_buffer,
                           CORBA_Environment * ev,
                           CORBA_unsigned_long(*_impl_TimeLeft)
                           (PortableServer_Servant _servant,
                            CORBA_Environment * ev))
{
   CORBA_unsigned_long _ORBIT_retval;

   _ORBIT_retval = _impl_TimeLeft(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_retval));
             memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_retval));
          }
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_SandUhr_Timer_NotRunning_struct,
              (gpointer) _ORBIT_SandUhr_Timer_NotRunning_marshal},
             {CORBA_OBJECT_NIL, NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_SandUhr_TimerFactory_InvalidTime_marshal(GIOPSendBuffer *
                                    _ORBIT_send_buffer,
                                    CORBA_Environment * ev)
{
}
void
_ORBIT_skel_SandUhr_TimerFactory_CreateAlarmBeep(POA_SandUhr_TimerFactory *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     SandUhr_AlarmBeep
                                     (*_impl_CreateAlarmBeep)
                                     (PortableServer_Servant
                                      _servant,
                                      const CORBA_unsigned_short
                                      Count,
                                      CORBA_Environment * ev))
{
   SandUhr_AlarmBeep _ORBIT_retval;
   CORBA_unsigned_short Count;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
       (*((guint16 *) & (Count))) =
          GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
       Count = *((CORBA_unsigned_short *) _ORBIT_curptr);
      }
   }
   _ORBIT_retval = _impl_CreateAlarmBeep(_ORBIT_servant, Count, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_SandUhr_TimerFactory_CreateAlarmSound(POA_SandUhr_TimerFactory *
                                      _ORBIT_servant,
                                      GIOPRecvBuffer *
                                      _ORBIT_recv_buffer,
                                      CORBA_Environment * ev,
                                      SandUhr_AlarmSound
                                      (*_impl_CreateAlarmSound)
                                      (PortableServer_Servant
                                       _servant,
                                       const CORBA_char *
                                       SoundFile,
                                       CORBA_Environment * ev))
{
   SandUhr_AlarmSound _ORBIT_retval;
   CORBA_char *SoundFile;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       SoundFile = (void *) _ORBIT_curptr;
       _ORBIT_curptr +=
          sizeof(SoundFile[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       SoundFile = (void *) _ORBIT_curptr;
       _ORBIT_curptr +=
          sizeof(SoundFile[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _ORBIT_retval = _impl_CreateAlarmSound(_ORBIT_servant, SoundFile, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_SandUhr_TimerFactory_CreateAlarmCommand(POA_SandUhr_TimerFactory *
                                        _ORBIT_servant,
                                        GIOPRecvBuffer *
                                        _ORBIT_recv_buffer,
                                        CORBA_Environment * ev,
                                        SandUhr_AlarmCommand
                                        (*_impl_CreateAlarmCommand)
                                        (PortableServer_Servant
                                         _servant,
                                         const CORBA_char *
                                         CommandString,
                                         CORBA_Environment * ev))
{
   SandUhr_AlarmCommand _ORBIT_retval;
   CORBA_char *CommandString;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       CommandString = (void *) _ORBIT_curptr;
       _ORBIT_curptr +=
          sizeof(CommandString[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       CommandString = (void *) _ORBIT_curptr;
       _ORBIT_curptr +=
          sizeof(CommandString[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _ORBIT_retval =
      _impl_CreateAlarmCommand(_ORBIT_servant, CommandString, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_SandUhr_TimerFactory_CreateTimer(POA_SandUhr_TimerFactory *
                                   _ORBIT_servant,
                                   GIOPRecvBuffer *
                                   _ORBIT_recv_buffer,
                                   CORBA_Environment * ev,
                                   SandUhr_Timer(*_impl_CreateTimer)
                                   (PortableServer_Servant _servant,
                                    const CORBA_char * TimeSpec,
                                    const CORBA_char * Message,
                                    CORBA_Environment * ev))
{
   SandUhr_Timer _ORBIT_retval;
   CORBA_char *TimeSpec;
   CORBA_char *Message;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_4;
      CORBA_unsigned_long _ORBIT_tmpvar_5;
      register CORBA_unsigned_long _ORBIT_tmpvar_6;
      CORBA_unsigned_long _ORBIT_tmpvar_7;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_5))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       TimeSpec = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(TimeSpec[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_7))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       Message = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(Message[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_5 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       TimeSpec = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(TimeSpec[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_7 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       Message = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(Message[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7;
      }
   }
   _ORBIT_retval = _impl_CreateTimer(_ORBIT_servant, TimeSpec, Message, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode)
              &TC_SandUhr_TimerFactory_InvalidTime_struct,
              (gpointer) _ORBIT_SandUhr_TimerFactory_InvalidTime_marshal},
             {CORBA_OBJECT_NIL, NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_SandUhr_TimerFactory__get_Timers(POA_SandUhr_TimerFactory *
                                   _ORBIT_servant,
                                   GIOPRecvBuffer *
                                   _ORBIT_recv_buffer,
                                   CORBA_Environment * ev,
                                   SandUhr_TimerFactory_TimerVec *
                                   (*_impl__get_Timers)
                                   (PortableServer_Servant _servant,
                                    CORBA_Environment * ev))
{
   SandUhr_TimerFactory_TimerVec *_ORBIT_retval;

   _ORBIT_retval = _impl__get_Timers(_ORBIT_servant, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;

          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*_ORBIT_retval)._length));
             memcpy(_ORBIT_t, &((*_ORBIT_retval)._length),
                  sizeof((*_ORBIT_retval)._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*_ORBIT_retval).
                                         _length));
          }
          for (_ORBIT_tmpvar_0 = 0;
             _ORBIT_tmpvar_0 < (*_ORBIT_retval)._length;
             _ORBIT_tmpvar_0++) {
             ORBit_marshal_object(_ORBIT_send_buffer,
                            (*_ORBIT_retval).
                            _buffer[_ORBIT_tmpvar_0]);
          }

       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_SandUhr_TimerFactory_ShowControl(POA_SandUhr_TimerFactory *
                                   _ORBIT_servant,
                                   GIOPRecvBuffer *
                                   _ORBIT_recv_buffer,
                                   CORBA_Environment * ev,
                                   void (*_impl_ShowControl)
                                   (PortableServer_Servant _servant,
                                    const CORBA_boolean Show,
                                    CORBA_Environment * ev))
{
   CORBA_boolean Show;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       Show = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
       Show = *((CORBA_boolean *) _ORBIT_curptr);
      }
   }
   _impl_ShowControl(_ORBIT_servant, Show, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
static ORBitSkeleton
get_skel_SandUhr_AlarmAction(POA_SandUhr_AlarmAction * servant,
                       GIOPRecvBuffer * _ORBIT_recv_buffer,
                       gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'A':
      if (strcmp((opname + 1), "ttach"))
         break;
      *impl = (gpointer) servant->vepv->SandUhr_AlarmAction_epv->Attach;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_AlarmAction_Attach;
      break;
     case 'D':
      switch (opname[1]) {
        case 'e':
           switch (opname[2]) {
             case 'l':
              if (strcmp((opname + 3), "iver"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Deliver;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Deliver;
              break;
             case 't':
              if (strcmp((opname + 3), "ach"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Detach;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Detach;
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case '_':
      if (strcmp((opname + 1), "get_NeedsPopup"))
         break;
      *impl =
         (gpointer) servant->vepv->SandUhr_AlarmAction_epv->_get_NeedsPopup;
      return (ORBitSkeleton)
         _ORBIT_skel_SandUhr_AlarmAction__get_NeedsPopup;
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_SandUhr_AlarmAction(CORBA_Object obj,
                              POA_SandUhr_AlarmAction * servant)
{
   obj->vepv[SandUhr_AlarmAction__classid] =
      servant->vepv->SandUhr_AlarmAction_epv;
}

void
POA_SandUhr_AlarmAction__init(PortableServer_Servant servant,
                        CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_SandUhr_AlarmAction,
"IDL:SandUhr/AlarmAction:1.0", (ORBit_local_objref_init) & init_local_objref_SandUhr_AlarmAction };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!SandUhr_AlarmAction__classid)
      SandUhr_AlarmAction__classid = ORBit_register_class(&class_info);
}

void
POA_SandUhr_AlarmAction__fini(PortableServer_Servant servant,
                        CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_SandUhr_AlarmBeep(POA_SandUhr_AlarmBeep * servant,
                     GIOPRecvBuffer * _ORBIT_recv_buffer,
                     gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'A':
      if (strcmp((opname + 1), "ttach"))
         break;
      *impl = (gpointer) servant->vepv->SandUhr_AlarmAction_epv->Attach;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_AlarmAction_Attach;
      break;
     case 'D':
      switch (opname[1]) {
        case 'e':
           switch (opname[2]) {
             case 'l':
              if (strcmp((opname + 3), "iver"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Deliver;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Deliver;
              break;
             case 't':
              if (strcmp((opname + 3), "ach"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Detach;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Detach;
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case '_':
      switch (opname[1]) {
        case 'g':
           switch (opname[2]) {
             case 'e':
              switch (opname[3]) {
                case 't':
                   switch (opname[4]) {
                   case '_':
                      switch (opname[5]) {
                        case 'C':
                         if (strcmp((opname + 6), "ount"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_AlarmBeep_epv->_get_Count;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_AlarmBeep__get_Count;
                         break;
                        case 'N':
                         if (strcmp((opname + 6), "eedsPopup"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_AlarmAction_epv->_get_NeedsPopup;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_AlarmAction__get_NeedsPopup;
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        case 's':
           if (strcmp((opname + 2), "et_Count"))
            break;
           *impl =
            (gpointer) servant->vepv->SandUhr_AlarmBeep_epv->_set_Count;
           return (ORBitSkeleton) _ORBIT_skel_SandUhr_AlarmBeep__set_Count;
           break;
        default:
           break;
      }
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_SandUhr_AlarmBeep(CORBA_Object obj,
                            POA_SandUhr_AlarmBeep * servant)
{
   obj->vepv[SandUhr_AlarmAction__classid] =
      servant->vepv->SandUhr_AlarmAction_epv;
   obj->vepv[SandUhr_AlarmBeep__classid] =
      servant->vepv->SandUhr_AlarmBeep_epv;
}

void
POA_SandUhr_AlarmBeep__init(PortableServer_Servant servant,
                      CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_SandUhr_AlarmBeep,
"IDL:SandUhr/AlarmBeep:1.0", (ORBit_local_objref_init) & init_local_objref_SandUhr_AlarmBeep };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   POA_SandUhr_AlarmAction__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!SandUhr_AlarmBeep__classid)
      SandUhr_AlarmBeep__classid = ORBit_register_class(&class_info);
}

void
POA_SandUhr_AlarmBeep__fini(PortableServer_Servant servant,
                      CORBA_Environment * env)
{
   POA_SandUhr_AlarmAction__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_SandUhr_AlarmSound(POA_SandUhr_AlarmSound * servant,
                      GIOPRecvBuffer * _ORBIT_recv_buffer,
                      gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'A':
      if (strcmp((opname + 1), "ttach"))
         break;
      *impl = (gpointer) servant->vepv->SandUhr_AlarmAction_epv->Attach;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_AlarmAction_Attach;
      break;
     case 'D':
      switch (opname[1]) {
        case 'e':
           switch (opname[2]) {
             case 'l':
              if (strcmp((opname + 3), "iver"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Deliver;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Deliver;
              break;
             case 't':
              if (strcmp((opname + 3), "ach"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Detach;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Detach;
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case '_':
      switch (opname[1]) {
        case 'g':
           switch (opname[2]) {
             case 'e':
              switch (opname[3]) {
                case 't':
                   switch (opname[4]) {
                   case '_':
                      switch (opname[5]) {
                        case 'N':
                         if (strcmp((opname + 6), "eedsPopup"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_AlarmAction_epv->_get_NeedsPopup;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_AlarmAction__get_NeedsPopup;
                         break;
                        case 'S':
                         if (strcmp((opname + 6), "oundFile"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_AlarmSound_epv->_get_SoundFile;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_AlarmSound__get_SoundFile;
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        case 's':
           if (strcmp((opname + 2), "et_SoundFile"))
            break;
           *impl =
            (gpointer) servant->vepv->SandUhr_AlarmSound_epv->
            _set_SoundFile;
           return (ORBitSkeleton)
            _ORBIT_skel_SandUhr_AlarmSound__set_SoundFile;
           break;
        default:
           break;
      }
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_SandUhr_AlarmSound(CORBA_Object obj,
                             POA_SandUhr_AlarmSound * servant)
{
   obj->vepv[SandUhr_AlarmAction__classid] =
      servant->vepv->SandUhr_AlarmAction_epv;
   obj->vepv[SandUhr_AlarmSound__classid] =
      servant->vepv->SandUhr_AlarmSound_epv;
}

void
POA_SandUhr_AlarmSound__init(PortableServer_Servant servant,
                       CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_SandUhr_AlarmSound,
"IDL:SandUhr/AlarmSound:1.0", (ORBit_local_objref_init) & init_local_objref_SandUhr_AlarmSound };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   POA_SandUhr_AlarmAction__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!SandUhr_AlarmSound__classid)
      SandUhr_AlarmSound__classid = ORBit_register_class(&class_info);
}

void
POA_SandUhr_AlarmSound__fini(PortableServer_Servant servant,
                       CORBA_Environment * env)
{
   POA_SandUhr_AlarmAction__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_SandUhr_AlarmCommand(POA_SandUhr_AlarmCommand * servant,
                        GIOPRecvBuffer * _ORBIT_recv_buffer,
                        gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'A':
      if (strcmp((opname + 1), "ttach"))
         break;
      *impl = (gpointer) servant->vepv->SandUhr_AlarmAction_epv->Attach;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_AlarmAction_Attach;
      break;
     case 'D':
      switch (opname[1]) {
        case 'e':
           switch (opname[2]) {
             case 'l':
              if (strcmp((opname + 3), "iver"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Deliver;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Deliver;
              break;
             case 't':
              if (strcmp((opname + 3), "ach"))
                 break;
              *impl =
                 (gpointer) servant->vepv->SandUhr_AlarmAction_epv->
                 Detach;
              return (ORBitSkeleton)
                 _ORBIT_skel_SandUhr_AlarmAction_Detach;
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case '_':
      switch (opname[1]) {
        case 'g':
           switch (opname[2]) {
             case 'e':
              switch (opname[3]) {
                case 't':
                   switch (opname[4]) {
                   case '_':
                      switch (opname[5]) {
                        case 'C':
                         if (strcmp((opname + 6), "ommandString"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_AlarmCommand_epv->
                            _get_CommandString;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_AlarmCommand__get_CommandString;
                         break;
                        case 'N':
                         if (strcmp((opname + 6), "eedsPopup"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_AlarmAction_epv->_get_NeedsPopup;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_AlarmAction__get_NeedsPopup;
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        case 's':
           if (strcmp((opname + 2), "et_CommandString"))
            break;
           *impl =
            (gpointer) servant->vepv->SandUhr_AlarmCommand_epv->
            _set_CommandString;
           return (ORBitSkeleton)
            _ORBIT_skel_SandUhr_AlarmCommand__set_CommandString;
           break;
        default:
           break;
      }
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_SandUhr_AlarmCommand(CORBA_Object obj,
                               POA_SandUhr_AlarmCommand * servant)
{
   obj->vepv[SandUhr_AlarmAction__classid] =
      servant->vepv->SandUhr_AlarmAction_epv;
   obj->vepv[SandUhr_AlarmCommand__classid] =
      servant->vepv->SandUhr_AlarmCommand_epv;
}

void
POA_SandUhr_AlarmCommand__init(PortableServer_Servant servant,
                         CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_SandUhr_AlarmCommand,
"IDL:SandUhr/AlarmCommand:1.0", (ORBit_local_objref_init) & init_local_objref_SandUhr_AlarmCommand };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   POA_SandUhr_AlarmAction__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!SandUhr_AlarmCommand__classid)
      SandUhr_AlarmCommand__classid = ORBit_register_class(&class_info);
}

void
POA_SandUhr_AlarmCommand__fini(PortableServer_Servant servant,
                         CORBA_Environment * env)
{
   POA_SandUhr_AlarmAction__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_SandUhr_Timer(POA_SandUhr_Timer * servant,
                   GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'D':
      if (strcmp((opname + 1), "estroy"))
         break;
      *impl = (gpointer) servant->vepv->SandUhr_Timer_epv->Destroy;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_Timer_Destroy;
      break;
     case 'T':
      if (strcmp((opname + 1), "imeLeft"))
         break;
      *impl = (gpointer) servant->vepv->SandUhr_Timer_epv->TimeLeft;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_Timer_TimeLeft;
      break;
     case '_':
      switch (opname[1]) {
        case 'g':
           switch (opname[2]) {
             case 'e':
              switch (opname[3]) {
                case 't':
                   switch (opname[4]) {
                   case '_':
                      switch (opname[5]) {
                        case 'A':
                         if (strcmp((opname + 6), "larm"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_get_Alarm;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__get_Alarm;
                         break;
                        case 'M':
                         if (strcmp((opname + 6), "essage"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_get_Message;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__get_Message;
                         break;
                        case 'S':
                         switch (opname[6]) {
                           case 'a':
                              if (strcmp((opname + 7), "ndColor"))
                               break;
                              *impl =
                               (gpointer) servant->vepv->
                               SandUhr_Timer_epv->_get_SandColor;
                              return (ORBitSkeleton)
                               _ORBIT_skel_SandUhr_Timer__get_SandColor;
                              break;
                           case 't':
                              if (strcmp((opname + 7), "ate"))
                               break;
                              *impl =
                               (gpointer) servant->vepv->
                               SandUhr_Timer_epv->_get_State;
                              return (ORBitSkeleton)
                               _ORBIT_skel_SandUhr_Timer__get_State;
                              break;
                           default:
                              break;
                         }
                         break;
                        case 'T':
                         if (strcmp((opname + 6), "imeSpec"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_get_TimeSpec;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__get_TimeSpec;
                         break;
                        case 'W':
                         switch (opname[6]) {
                           case 'i':
                              switch (opname[7]) {
                              case 'n':
                                 switch (opname[8]) {
                                   case 'd':
                                    switch (opname[9]) {
                                      case 'o':
                                         switch (opname[10]) {
                                           case 'w':
                                            switch (opname[11]) {
                                              case 'D':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "ecorations"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_Timer_epv->
                                                  _get_WindowDecorations;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_Timer__get_WindowDecorations;
                                                 break;
                                              case 'L':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "ayer"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_Timer_epv->
                                                  _get_WindowLayer;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_Timer__get_WindowLayer;
                                                 break;
                                              default:
                                                 break;
                                            }
                                            break;
                                           default:
                                            break;
                                         }
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        case 's':
           switch (opname[2]) {
             case 'e':
              switch (opname[3]) {
                case 't':
                   switch (opname[4]) {
                   case '_':
                      switch (opname[5]) {
                        case 'A':
                         if (strcmp((opname + 6), "larm"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_set_Alarm;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__set_Alarm;
                         break;
                        case 'M':
                         if (strcmp((opname + 6), "essage"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_set_Message;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__set_Message;
                         break;
                        case 'S':
                         if (strcmp((opname + 6), "andColor"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_set_SandColor;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__set_SandColor;
                         break;
                        case 'T':
                         if (strcmp((opname + 6), "imeSpec"))
                            break;
                         *impl =
                            (gpointer) servant->vepv->
                            SandUhr_Timer_epv->_set_TimeSpec;
                         return (ORBitSkeleton)
                            _ORBIT_skel_SandUhr_Timer__set_TimeSpec;
                         break;
                        case 'W':
                         switch (opname[6]) {
                           case 'i':
                              switch (opname[7]) {
                              case 'n':
                                 switch (opname[8]) {
                                   case 'd':
                                    switch (opname[9]) {
                                      case 'o':
                                         switch (opname[10]) {
                                           case 'w':
                                            switch (opname[11]) {
                                              case 'D':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "ecorations"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_Timer_epv->
                                                  _set_WindowDecorations;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_Timer__set_WindowDecorations;
                                                 break;
                                              case 'L':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "ayer"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_Timer_epv->
                                                  _set_WindowLayer;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_Timer__set_WindowLayer;
                                                 break;
                                              default:
                                                 break;
                                            }
                                            break;
                                           default:
                                            break;
                                         }
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_SandUhr_Timer(CORBA_Object obj, POA_SandUhr_Timer * servant)
{
   obj->vepv[SandUhr_Timer__classid] = servant->vepv->SandUhr_Timer_epv;
}

void
POA_SandUhr_Timer__init(PortableServer_Servant servant,
                  CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_SandUhr_Timer, "IDL:SandUhr/Timer:1.0",
(ORBit_local_objref_init) & init_local_objref_SandUhr_Timer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!SandUhr_Timer__classid)
      SandUhr_Timer__classid = ORBit_register_class(&class_info);
}

void
POA_SandUhr_Timer__fini(PortableServer_Servant servant,
                  CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_SandUhr_TimerFactory(POA_SandUhr_TimerFactory * servant,
                        GIOPRecvBuffer * _ORBIT_recv_buffer,
                        gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'C':
      switch (opname[1]) {
        case 'r':
           switch (opname[2]) {
             case 'e':
              switch (opname[3]) {
                case 'a':
                   switch (opname[4]) {
                   case 't':
                      switch (opname[5]) {
                        case 'e':
                         switch (opname[6]) {
                           case 'A':
                              switch (opname[7]) {
                              case 'l':
                                 switch (opname[8]) {
                                   case 'a':
                                    switch (opname[9]) {
                                      case 'r':
                                         switch (opname[10]) {
                                           case 'm':
                                            switch (opname[11]) {
                                              case 'B':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "eep"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_TimerFactory_epv->
                                                  CreateAlarmBeep;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_TimerFactory_CreateAlarmBeep;
                                                 break;
                                              case 'C':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "ommand"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_TimerFactory_epv->
                                                  CreateAlarmCommand;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_TimerFactory_CreateAlarmCommand;
                                                 break;
                                              case 'S':
                                                 if (strcmp
                                                   ((opname +
                                                     12),
                                                    "ound"))
                                                  break;
                                                 *impl =
                                                  (gpointer)
                                                  servant->
                                                  vepv->
                                                  SandUhr_TimerFactory_epv->
                                                  CreateAlarmSound;
                                                 return
                                                  (ORBitSkeleton)
                                                  _ORBIT_skel_SandUhr_TimerFactory_CreateAlarmSound;
                                                 break;
                                              default:
                                                 break;
                                            }
                                            break;
                                           default:
                                            break;
                                         }
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           case 'T':
                              if (strcmp((opname + 7), "imer"))
                               break;
                              *impl =
                               (gpointer) servant->vepv->
                               SandUhr_TimerFactory_epv->
                               CreateTimer;
                              return (ORBitSkeleton)
                               _ORBIT_skel_SandUhr_TimerFactory_CreateTimer;
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'S':
      if (strcmp((opname + 1), "howControl"))
         break;
      *impl =
         (gpointer) servant->vepv->SandUhr_TimerFactory_epv->ShowControl;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_TimerFactory_ShowControl;
      break;
     case '_':
      if (strcmp((opname + 1), "get_Timers"))
         break;
      *impl =
         (gpointer) servant->vepv->SandUhr_TimerFactory_epv->_get_Timers;
      return (ORBitSkeleton) _ORBIT_skel_SandUhr_TimerFactory__get_Timers;
      break;
     case 'c':
      if (strcmp((opname + 1), "reate_object"))
         break;
      *impl =
         (gpointer) servant->vepv->GNOME_ObjectFactory_epv->create_object;
      return (ORBitSkeleton) _ORBIT_skel_GNOME_ObjectFactory_create_object;
      break;
     case 'm':
      if (strcmp((opname + 1), "anufactures"))
         break;
      *impl =
         (gpointer) servant->vepv->GNOME_ObjectFactory_epv->manufactures;
      return (ORBitSkeleton) _ORBIT_skel_GNOME_ObjectFactory_manufactures;
      break;
     case 'r':
      if (strcmp((opname + 1), "ef"))
         break;
      *impl = (gpointer) servant->vepv->GNOME_ObjectFactory_epv->ref;
      return (ORBitSkeleton) _ORBIT_skel_GNOME_ObjectFactory_ref;
      break;
     case 'u':
      if (strcmp((opname + 1), "nref"))
         break;
      *impl = (gpointer) servant->vepv->GNOME_ObjectFactory_epv->unref;
      return (ORBitSkeleton) _ORBIT_skel_GNOME_ObjectFactory_unref;
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_SandUhr_TimerFactory(CORBA_Object obj,
                               POA_SandUhr_TimerFactory * servant)
{
   obj->vepv[GNOME_ObjectFactory__classid] =
      servant->vepv->GNOME_ObjectFactory_epv;
   obj->vepv[SandUhr_TimerFactory__classid] =
      servant->vepv->SandUhr_TimerFactory_epv;
}

void
POA_SandUhr_TimerFactory__init(PortableServer_Servant servant,
                         CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_SandUhr_TimerFactory,
"IDL:SandUhr/TimerFactory:1.0", (ORBit_local_objref_init) & init_local_objref_SandUhr_TimerFactory };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   POA_GNOME_ObjectFactory__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!SandUhr_TimerFactory__classid)
      SandUhr_TimerFactory__classid = ORBit_register_class(&class_info);
}

void
POA_SandUhr_TimerFactory__fini(PortableServer_Servant servant,
                         CORBA_Environment * env)
{
   POA_GNOME_ObjectFactory__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

Generated by  Doxygen 1.6.0   Back to index