store.h

mico_example_siegel c源代码

#if !defined(__STORE_H__) || defined(MICO_NO_TOPLEVEL_MODULES)
#define __STORE_H__

#ifndef MICO_NO_TOPLEVEL_MODULES
#include <CORBA.h>
#include <mico/throw.h>
#endif

#ifdef MICO_IN_GENERATED_CODE
#include "POS.h"
#else
#define MICO_IN_GENERATED_CODE
#include "POS.h"
#undef MICO_IN_GENERATED_CODE
#endif

#ifndef MICO_NO_TOPLEVEL_MODULES
MICO_NAMESPACE_DECL AStore {
#endif

#if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_AStore)


enum ItemTypes {
  food = 0,
  clothes,
  other
};

typedef ItemTypes& ItemTypes_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ItemTypes;

typedef CORBA::Long AStoreId;
MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_AStoreId;

struct ItemInfo {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ItemInfo();
  ~ItemInfo();
  ItemInfo( const ItemInfo& s );
  ItemInfo& operator=( const ItemInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  POS::Barcode_var Item;
  ItemTypes Itemtype;
  CORBA::Float Itemcost;
  CORBA::String_var Name;
  CORBA::Long Quantity;
};

typedef TVarVar<ItemInfo> ItemInfo_var;
typedef ItemInfo_var ItemInfo_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ItemInfo;

struct BarcodeNotFound : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  BarcodeNotFound();
  ~BarcodeNotFound();
  BarcodeNotFound( const BarcodeNotFound& s );
  BarcodeNotFound& operator=( const BarcodeNotFound& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  CORBA::Exception *_clone() const;
  static BarcodeNotFound *_narrow( CORBA::Exception *ex );
  POS::Barcode_var item;
};

typedef ExceptVar<BarcodeNotFound> BarcodeNotFound_var;
typedef BarcodeNotFound_var BarcodeNotFound_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_BarcodeNotFound;

class StoreAccess;
typedef StoreAccess *StoreAccess_ptr;
typedef StoreAccess_ptr StoreAccessRef;
typedef ObjVar<StoreAccess> StoreAccess_var;
typedef StoreAccess_var StoreAccess_out;

struct POSInfo {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  POSInfo();
  ~POSInfo();
  POSInfo( const POSInfo& s );
  POSInfo& operator=( const POSInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  POS::POSId Id;
  StoreAccess_var StoreAccessReference;
  CORBA::Float TotalSales;
  CORBA::Float TotalTaxes;
};

typedef TVarVar<POSInfo> POSInfo_var;
typedef POSInfo_var POSInfo_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_POSInfo;

typedef SequenceTmpl<POSInfo> POSList;
#ifdef _WINDOWS
static POSList _dummy_POSList;
#endif
typedef TSeqVar<SequenceTmpl<POSInfo> > POSList_var;
typedef POSList_var POSList_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_POSList;

class Tax;
typedef Tax *Tax_ptr;
typedef Tax_ptr TaxRef;
typedef ObjVar<Tax> Tax_var;
typedef Tax_var Tax_out;


// Common definitions for interface Tax
class Tax : virtual public CORBA::Object
{
  public:
    virtual ~Tax();
    static Tax_ptr _duplicate( Tax_ptr obj );
    static Tax_ptr _narrow( CORBA::Object_ptr obj );
    static Tax_ptr _nil();

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    virtual CORBA::Float CalculateTax( CORBA::Float TaxableAmount ) = 0;
    virtual CORBA::Float FindTaxablePrice( CORBA::Float ItemPrice, ItemTypes ItemType ) = 0;
  protected:
    Tax() {};
  private:
    Tax( const Tax& );
    void operator=( const Tax& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_Tax;

// Stub for interface Tax
class Tax_stub : virtual public Tax
{
  public:
    virtual ~Tax_stub();
    CORBA::Float CalculateTax( CORBA::Float TaxableAmount );
    CORBA::Float FindTaxablePrice( CORBA::Float ItemPrice, ItemTypes ItemType );
  private:
    void operator=( const Tax_stub& );
};

class Tax_skel :
  virtual public MethodDispatcher,
  virtual public Tax
{
  public:
    Tax_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Tax_skel();
    Tax_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::ServerRequest_ptr _req, CORBA::Environment &_env );
    Tax_ptr _this();

};

class Store;
typedef Store *Store_ptr;
typedef Store_ptr StoreRef;
typedef ObjVar<Store> Store_var;
typedef Store_var Store_out;


// Common definitions for interface Store
class Store : virtual public CORBA::Object
{
  public:
    virtual ~Store();
    static Store_ptr _duplicate( Store_ptr obj );
    static Store_ptr _narrow( CORBA::Object_ptr obj );
    static Store_ptr _nil();

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    struct StoreTotals {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      StoreTotals();
      ~StoreTotals();
      StoreTotals( const StoreTotals& s );
      StoreTotals& operator=( const StoreTotals& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      CORBA::Float StoreTotal;
      CORBA::Float StoreTaxTotal;
    };

    typedef TFixVar<StoreTotals> StoreTotals_var;
    typedef StoreTotals_var StoreTotals_out;

    static CORBA::TypeCodeConst _tc_StoreTotals;

    virtual AStoreId StoreId() = 0;
    virtual StoreTotals Totals() = 0;
    virtual StoreAccess_ptr Login( POS::POSId Id ) = 0;
    virtual void GetPOSTotals( POSList*& POSData ) = 0;
    virtual void UpdateStoreTotals( POS::POSId Id, CORBA::Float Price, CORBA::Float Taxes ) = 0;
  protected:
    Store() {};
  private:
    Store( const Store& );
    void operator=( const Store& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_Store;

// Stub for interface Store
class Store_stub : virtual public Store
{
  public:
    virtual ~Store_stub();
    AStoreId StoreId();
    StoreTotals Totals();
    StoreAccess_ptr Login( POS::POSId Id );
    void GetPOSTotals( POSList*& POSData );
    void UpdateStoreTotals( POS::POSId Id, CORBA::Float Price, CORBA::Float Taxes );
  private:
    void operator=( const Store_stub& );
};

class Store_skel :
  virtual public MethodDispatcher,
  virtual public Store
{
  public:
    Store_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Store_skel();
    Store_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::ServerRequest_ptr _req, CORBA::Environment &_env );
    Store_ptr _this();

};


// Common definitions for interface StoreAccess
class StoreAccess : virtual public CORBA::Object
{
  public:
    virtual ~StoreAccess();
    static StoreAccess_ptr _duplicate( StoreAccess_ptr obj );
    static StoreAccess_ptr _narrow( CORBA::Object_ptr obj );
    static StoreAccess_ptr _nil();

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    virtual void FindPrice( const char* Item, CORBA::Long Quantity, CORBA::Float& ItemPrice, CORBA::Float& ItemTaxPrice, ItemInfo*& IInfo ) = 0;
  protected:
    StoreAccess() {};
  private:
    StoreAccess( const StoreAccess& );
    void operator=( const StoreAccess& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_StoreAccess;

// Stub for interface StoreAccess
class StoreAccess_stub : virtual public StoreAccess
{
  public:
    virtual ~StoreAccess_stub();
    void FindPrice( const char* Item, CORBA::Long Quantity, CORBA::Float& ItemPrice, CORBA::Float& ItemTaxPrice, ItemInfo*& IInfo );
  private:
    void operator=( const StoreAccess_stub& );
};

class StoreAccess_skel :
  virtual public MethodDispatcher,
  virtual public StoreAccess
{
  public:
    StoreAccess_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~StoreAccess_skel();
    StoreAccess_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::ServerRequest_ptr _req, CORBA::Environment &_env );
    StoreAccess_ptr _this();

};

#endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE_AStore)

#ifndef MICO_NO_TOPLEVEL_MODULES

};
#endif



#if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL)

CORBA::Boolean operator<<=( CORBA::Any &a, const ::AStore::ItemTypes &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::AStore::ItemTypes &e );

CORBA::Boolean operator<<=( CORBA::Any &_a, const ::AStore::ItemInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::AStore::ItemInfo &_s );

CORBA::Boolean operator<<=( CORBA::Any &a, const ::AStore::BarcodeNotFound &e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::AStore::BarcodeNotFound &e );

CORBA::Boolean operator<<=( CORBA::Any &_a, const ::AStore::POSInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::AStore::POSInfo &_s );

CORBA::Boolean operator<<=( CORBA::Any &a, const AStore::Tax_ptr obj );
CORBA::Boolean operator>>=( const CORBA::Any &a, AStore::Tax_ptr &obj );

CORBA::Boolean operator<<=( CORBA::Any &_a, const ::AStore::Store::StoreTotals &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::AStore::Store::StoreTotals &_s );

CORBA::Boolean operator<<=( CORBA::Any &a, const AStore::Store_ptr obj );
CORBA::Boolean operator>>=( const CORBA::Any &a, AStore::Store_ptr &obj );

CORBA::Boolean operator<<=( CORBA::Any &a, const AStore::StoreAccess_ptr obj );
CORBA::Boolean operator>>=( const CORBA::Any &a, AStore::StoreAccess_ptr &obj );

CORBA::Boolean operator<<=( CORBA::Any &_a, const SequenceTmpl<AStore::POSInfo> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<AStore::POSInfo> &_s );

#endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL)


#if !defined(MICO_NO_TOPLEVEL_MODULES) && !defined(MICO_IN_GENERATED_CODE)
#include <mico/template_impl.h>
#endif

#endif