pos.c

mico_example_siegel c源代码

#include "POS.h"

//--------------------------------------------------------
//  Implementation of stubs
//--------------------------------------------------------
#ifdef HAVE_NAMESPACE
namespace POS { CORBA::TypeCodeConst _tc_POSId; };
#else
CORBA::TypeCodeConst POS::_tc_POSId;
#endif

#ifdef HAVE_NAMESPACE
namespace POS { CORBA::TypeCodeConst _tc_Barcode; };
#else
CORBA::TypeCodeConst POS::_tc_Barcode;
#endif

#ifdef HAVE_NAMESPACE
namespace POS { CORBA::TypeCodeConst InputMedia::_tc_OperatorCmd; };
#else
CORBA::TypeCodeConst POS::InputMedia::_tc_OperatorCmd;
#endif


// Stub interface InputMedia
POS::InputMedia::~InputMedia()
{
}

POS::InputMedia_ptr POS::InputMedia::_duplicate( InputMedia_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) )
    _obj->_ref();
  return _obj;
}

void *POS::InputMedia::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:POS/InputMedia:1.0" ) == 0 )
    return (void *)this;
  return NULL;
}

bool POS::InputMedia::_narrow_helper2( CORBA::Object_ptr _obj )
{
  if( strcmp( _obj->_repoid(), "IDL:POS/InputMedia:1.0" ) == 0) {
    return true;
  }
  for( vector<CORBA::Narrow_proto>::size_type _i = 0;
       _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
    bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
    if( _res )
      return true;
  }
  return false;
}

POS::InputMedia_ptr POS::InputMedia::_narrow( CORBA::Object_ptr _obj )
{
  POS::InputMedia_ptr _o;
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:POS/InputMedia:1.0" )))
      return _duplicate( (POS::InputMedia_ptr) _p );
    if( _narrow_helper2( _obj ) ) {
      _o = new POS::InputMedia_stub;
      _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
      return _o;
    }
  }
  return _nil();
}

POS::InputMedia_ptr POS::InputMedia::_nil()
{
  return NULL;
}

POS::InputMedia_stub::~InputMedia_stub()
{
}

void POS::InputMedia_stub::BarcodeInput( const char* Item )
{
  CORBA::Request_var _req = this->_request( "BarcodeInput" );
  _req->add_in_arg( "Item" ) <<= CORBA::Any::from_string( (char *) Item, 0 );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


void POS::InputMedia_stub::KeypadInput( const char* Cmd )
{
  CORBA::Request_var _req = this->_request( "KeypadInput" );
  _req->add_in_arg( "Cmd" ) <<= CORBA::Any::from_string( (char *) Cmd, 0 );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


#ifdef HAVE_NAMESPACE
namespace POS { vector<CORBA::Narrow_proto> * InputMedia::_narrow_helpers; };
#else
vector<CORBA::Narrow_proto> * POS::InputMedia::_narrow_helpers;
#endif
#ifdef HAVE_NAMESPACE
namespace POS { CORBA::TypeCodeConst _tc_InputMedia; };
#else
CORBA::TypeCodeConst POS::_tc_InputMedia;
#endif

CORBA::Boolean
operator<<=( CORBA::Any &_a, const POS::InputMedia_ptr _obj )
{
  return (_a <<= CORBA::Any::from_object( _obj, "InputMedia" ));
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, POS::InputMedia_ptr &_obj )
{
  CORBA::Object_ptr _o;
  if( !(_a >>= CORBA::Any::to_object( _o )) )
    return FALSE;
  if( CORBA::is_nil( _o ) ) {
    _obj = ::POS::InputMedia::_nil();
    return TRUE;
  }
  _obj = ::POS::InputMedia::_narrow( _o );
  CORBA::release( _o );
  return TRUE;
}


// Stub interface OutputMedia
POS::OutputMedia::~OutputMedia()
{
}

POS::OutputMedia_ptr POS::OutputMedia::_duplicate( OutputMedia_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) )
    _obj->_ref();
  return _obj;
}

void *POS::OutputMedia::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:POS/OutputMedia:1.0" ) == 0 )
    return (void *)this;
  return NULL;
}

bool POS::OutputMedia::_narrow_helper2( CORBA::Object_ptr _obj )
{
  if( strcmp( _obj->_repoid(), "IDL:POS/OutputMedia:1.0" ) == 0) {
    return true;
  }
  for( vector<CORBA::Narrow_proto>::size_type _i = 0;
       _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
    bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
    if( _res )
      return true;
  }
  return false;
}

POS::OutputMedia_ptr POS::OutputMedia::_narrow( CORBA::Object_ptr _obj )
{
  POS::OutputMedia_ptr _o;
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:POS/OutputMedia:1.0" )))
      return _duplicate( (POS::OutputMedia_ptr) _p );
    if( _narrow_helper2( _obj ) ) {
      _o = new POS::OutputMedia_stub;
      _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
      return _o;
    }
  }
  return _nil();
}

POS::OutputMedia_ptr POS::OutputMedia::_nil()
{
  return NULL;
}

POS::OutputMedia_stub::~OutputMedia_stub()
{
}

CORBA::Boolean POS::OutputMedia_stub::OutputText( const char* StringToPrint )
{
  CORBA::Request_var _req = this->_request( "OutputText" );
  _req->add_in_arg( "StringToPrint" ) <<= CORBA::Any::from_string( (char *) StringToPrint, 0 );
  _req->result()->value()->type( CORBA::_tc_boolean );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
  CORBA::Boolean _res;
  *_req->result()->value() >>= CORBA::Any::to_boolean( _res );
  return _res;
}


#ifdef HAVE_NAMESPACE
namespace POS { vector<CORBA::Narrow_proto> * OutputMedia::_narrow_helpers; };
#else
vector<CORBA::Narrow_proto> * POS::OutputMedia::_narrow_helpers;
#endif
#ifdef HAVE_NAMESPACE
namespace POS { CORBA::TypeCodeConst _tc_OutputMedia; };
#else
CORBA::TypeCodeConst POS::_tc_OutputMedia;
#endif

CORBA::Boolean
operator<<=( CORBA::Any &_a, const POS::OutputMedia_ptr _obj )
{
  return (_a <<= CORBA::Any::from_object( _obj, "OutputMedia" ));
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, POS::OutputMedia_ptr &_obj )
{
  CORBA::Object_ptr _o;
  if( !(_a >>= CORBA::Any::to_object( _o )) )
    return FALSE;
  if( CORBA::is_nil( _o ) ) {
    _obj = ::POS::OutputMedia::_nil();
    return TRUE;
  }
  _obj = ::POS::OutputMedia::_narrow( _o );
  CORBA::release( _o );
  return TRUE;
}


// Stub interface POSTerminal
POS::POSTerminal::~POSTerminal()
{
}

POS::POSTerminal_ptr POS::POSTerminal::_duplicate( POSTerminal_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) )
    _obj->_ref();
  return _obj;
}

void *POS::POSTerminal::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:POS/POSTerminal:1.0" ) == 0 )
    return (void *)this;
  return NULL;
}

bool POS::POSTerminal::_narrow_helper2( CORBA::Object_ptr _obj )
{
  if( strcmp( _obj->_repoid(), "IDL:POS/POSTerminal:1.0" ) == 0) {
    return true;
  }
  for( vector<CORBA::Narrow_proto>::size_type _i = 0;
       _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
    bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
    if( _res )
      return true;
  }
  return false;
}

POS::POSTerminal_ptr POS::POSTerminal::_narrow( CORBA::Object_ptr _obj )
{
  POS::POSTerminal_ptr _o;
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:POS/POSTerminal:1.0" )))
      return _duplicate( (POS::POSTerminal_ptr) _p );
    if( _narrow_helper2( _obj ) ) {
      _o = new POS::POSTerminal_stub;
      _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
      return _o;
    }
  }
  return _nil();
}

POS::POSTerminal_ptr POS::POSTerminal::_nil()
{
  return NULL;
}

POS::POSTerminal_stub::~POSTerminal_stub()
{
}

void POS::POSTerminal_stub::Login()
{
  CORBA::Request_var _req = this->_request( "Login" );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


void POS::POSTerminal_stub::PrintPOSSalesSummary()
{
  CORBA::Request_var _req = this->_request( "PrintPOSSalesSummary" );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


void POS::POSTerminal_stub::PrintStoreSalesSummary()
{
  CORBA::Request_var _req = this->_request( "PrintStoreSalesSummary" );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


void POS::POSTerminal_stub::SendBarcode( const char* Item )
{
  CORBA::Request_var _req = this->_request( "SendBarcode" );
  _req->add_in_arg( "Item" ) <<= CORBA::Any::from_string( (char *) Item, 0 );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


void POS::POSTerminal_stub::ItemQuantity( CORBA::Long Quantity )
{