steelworks.h

Go to the documentation of this file.

/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2003 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __STEELWORKS_H__
#define __STEELWORKS_H__






namespace Steelworks
{

class Listener;
typedef Listener *Listener_ptr;
typedef Listener_ptr ListenerRef;
typedef ObjVar< Listener > Listener_var;
typedef ObjOut< Listener > Listener_out;

class IDLConsts;
typedef IDLConsts *IDLConsts_ptr;
typedef IDLConsts_ptr IDLConstsRef;
typedef ObjVar< IDLConsts > IDLConsts_var;
typedef ObjOut< IDLConsts > IDLConsts_out;

}






namespace Steelworks
{

struct Ring;
typedef TFixVar< Ring > Ring_var;
typedef Ring& Ring_out;


struct Ring {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef Ring_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  Ring();
  ~Ring();
  Ring( const Ring& s );
  Ring& operator=( const Ring& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  CORBA::Long no;
  CORBA::Long reqNumber;
};

typedef SequenceTmpl< Ring,MICO_TID_DEF> RingSet;
typedef TSeqVar< SequenceTmpl< Ring,MICO_TID_DEF> > RingSet_var;
typedef TSeqOut< SequenceTmpl< Ring,MICO_TID_DEF> > RingSet_out;

struct Stack;
typedef TVarVar< Stack > Stack_var;
typedef TVarOut< Stack > Stack_out;


struct Stack {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef Stack_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  Stack();
  ~Stack();
  Stack( const Stack& s );
  Stack& operator=( const Stack& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  CORBA::Long x;
  CORBA::Long y;
  CORBA::Double height;
  CORBA::Double maxDiameter;
  RingSet rings;
};

typedef SequenceTmpl< Stack,MICO_TID_DEF> StackSet;
typedef TSeqVar< SequenceTmpl< Stack,MICO_TID_DEF> > StackSet_var;
typedef TSeqOut< SequenceTmpl< Stack,MICO_TID_DEF> > StackSet_out;

struct Pallet;
typedef TVarVar< Pallet > Pallet_var;
typedef TVarOut< Pallet > Pallet_out;


struct Pallet {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef Pallet_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  Pallet();
  ~Pallet();
  Pallet( const Pallet& s );
  Pallet& operator=( const Pallet& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  CORBA::Long number;
  StackSet stacks;
};

struct Request;
typedef TVarVar< Request > Request_var;
typedef TVarOut< Request > Request_out;


struct Request {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef Request_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  Request();
  ~Request();
  Request( const Request& s );
  Request& operator=( const Request& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  CORBA::Long number;
  CORBA::String_var startTime;
  CORBA::String_var treatment;
  CORBA::String_var steelType;
  CORBA::Double diameter;
  CORBA::Double height;
  CORBA::Double weight;
  CORBA::Long numberOfRings;
  CORBA::String_var comment;
};


/*
 * Base class and common definitions for interface Listener
 */

class Listener : 
  virtual public CORBA::Object
{
  public:
    virtual ~Listener();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Listener_ptr _ptr_type;
    typedef Listener_var _var_type;
    #endif

    static Listener_ptr _narrow( CORBA::Object_ptr obj );
    static Listener_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Listener_ptr _duplicate( Listener_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Listener_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void initialize() = 0;
    virtual void factorySetState( CORBA::Boolean state ) = 0;
    virtual void newRequest( const Request& req ) = 0;
    virtual void doneRequest( CORBA::Long number, const char* endTime ) = 0;
    virtual void setNumberOfRings( CORBA::Long reqNumber, CORBA::Long newNumber ) = 0;
    virtual void doneRing( CORBA::Long reqNumber ) = 0;
    virtual void moveVehicle( CORBA::Long number, CORBA::Long newPosition ) = 0;
    virtual void shift( CORBA::Long numberOfRow ) = 0;
    virtual void newPallet( const Pallet& p ) = 0;
    virtual void movePallet( CORBA::Long number, CORBA::Long newPosition ) = 0;
    virtual void palletChangesOwner( CORBA::Long palletNumber, CORBA::Long newOwner, CORBA::Long newSubOwner ) = 0;
    virtual void deletePallet( CORBA::Long number ) = 0;
    virtual void craneSetState( CORBA::Boolean moves ) = 0;
    virtual void craneMoveTo( CORBA::Long newPosition, CORBA::Long subPosition ) = 0;
    virtual void ovenSetState( CORBA::Long number, CORBA::Long newState ) = 0;
    virtual void storageSetState( CORBA::Long storageNumber, CORBA::Long state ) = 0;
    virtual void transmissionMoveTo( CORBA::Long position ) = 0;
    virtual void setTime( const char* time ) = 0;
    virtual void setDay( CORBA::Long day ) = 0;
    virtual void stop() = 0;

  protected:
    Listener() {};
  private:
    Listener( const Listener& );
    void operator=( const Listener& );
};

// Stub for interface Listener
class Listener_stub:
  virtual public Listener
{
  public:
    virtual ~Listener_stub();
    void initialize();
    void factorySetState( CORBA::Boolean state );
    void newRequest( const Request& req );
    void doneRequest( CORBA::Long number, const char* endTime );
    void setNumberOfRings( CORBA::Long reqNumber, CORBA::Long newNumber );
    void doneRing( CORBA::Long reqNumber );
    void moveVehicle( CORBA::Long number, CORBA::Long newPosition );
    void shift( CORBA::Long numberOfRow );
    void newPallet( const Pallet& p );
    void movePallet( CORBA::Long number, CORBA::Long newPosition );
    void palletChangesOwner( CORBA::Long palletNumber, CORBA::Long newOwner, CORBA::Long newSubOwner );
    void deletePallet( CORBA::Long number );
    void craneSetState( CORBA::Boolean moves );
    void craneMoveTo( CORBA::Long newPosition, CORBA::Long subPosition );
    void ovenSetState( CORBA::Long number, CORBA::Long newState );
    void storageSetState( CORBA::Long storageNumber, CORBA::Long state );
    void transmissionMoveTo( CORBA::Long position );
    void setTime( const char* time );
    void setDay( CORBA::Long day );
    void stop();

  private:
    void operator=( const Listener_stub& );
};

class Listener_skel :
  virtual public StaticMethodDispatcher,
  virtual public Listener
{
  public:
    Listener_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Listener_skel();
    Listener_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    Listener_ptr _this();

};


/*
 * Base class and common definitions for interface IDLConsts
 */

class IDLConsts : 
  virtual public CORBA::Object
{
  public:
    virtual ~IDLConsts();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef IDLConsts_ptr _ptr_type;
    typedef IDLConsts_var _var_type;
    #endif

    static IDLConsts_ptr _narrow( CORBA::Object_ptr obj );
    static IDLConsts_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static IDLConsts_ptr _duplicate( IDLConsts_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static IDLConsts_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    static const CORBA::Long CRANE_POS_UNLOAD;
    static const CORBA::Long CRANE_POS_OVEN;
    static const CORBA::Long CRANE_POS_BATH;
    static const CORBA::Long CRANE_POS_STORAGE;
    static const CORBA::Long CRANE_POS_TRANSMISSION;
    static const CORBA::Long CRANE_SUBPOS_STORE_PLACE_1;
    static const CORBA::Long CRANE_SUBPOS_STORE_PLACE_2;
    static const CORBA::Long CRANE_SUBPOS_STORE_PLACE_3;
    static const CORBA::Long CRANE_SUBPOS_FAN_PLACE;
    static const CORBA::Long CRANE_SUBPOS_POLYMER_BATH;
    static const CORBA::Long CRANE_SUBPOS_WATER_BATH;
    static const CORBA::Long PAL_POS_CRANE;
    static const CORBA::Long PAL_POS_OVEN;
    static const CORBA::Long PAL_POS_BATH;
    static const CORBA::Long PAL_POS_STORAGE;
    static const CORBA::Long PAL_POS_TRANSMISSION;
    static const CORBA::Long PAL_POS_BIGSTORAGE;
    static const CORBA::Long PAL_POS_HARDNESSTEST;
    static const CORBA::Long PAL_SUBPOS_STORE_PLACE_1;
    static const CORBA::Long PAL_SUBPOS_STORE_PLACE_2;
    static const CORBA::Long PAL_SUBPOS_STORE_PLACE_3;
    static const CORBA::Long PAL_SUBPOS_FAN_PLACE;
    static const CORBA::Long PAL_SUBPOS_POLYMER_BATH;
    static const CORBA::Long PAL_SUBPOS_WATER_BATH;
    static const CORBA::Long VEHICLE_POS_ROW1;
    static const CORBA::Long VEHICLE_POS_ROW2;
    static const CORBA::Long VEHICLE_POS_ROW3;
    static const CORBA::Long VEHICLE_POS_ROW4;
    static const CORBA::Long VEHICLE_POS_UNLOAD;
    static const CORBA::Long STORAGE_EMPTY;
    static const CORBA::Long STORAGE_PARKING;
    static const CORBA::Long STORAGE_AIRCOOLING;
    static const CORBA::Long STORAGE_VENTILATOR;
  protected:
    IDLConsts() {};
  private:
    IDLConsts( const IDLConsts& );
    void operator=( const IDLConsts& );
};

// Stub for interface IDLConsts
class IDLConsts_stub:
  virtual public IDLConsts
{
  public:
    virtual ~IDLConsts_stub();
  private:
    void operator=( const IDLConsts_stub& );
};

class IDLConsts_skel :
  virtual public StaticMethodDispatcher,
  virtual public IDLConsts
{
  public:
    IDLConsts_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~IDLConsts_skel();
    IDLConsts_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    IDLConsts_ptr _this();

};

}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

extern CORBA::StaticTypeInfo *_marshaller_Steelworks_Ring;

extern CORBA::StaticTypeInfo *_marshaller_Steelworks_Stack;

extern CORBA::StaticTypeInfo *_marshaller_Steelworks_Pallet;

extern CORBA::StaticTypeInfo *_marshaller_Steelworks_Request;

extern CORBA::StaticTypeInfo *_marshaller_Steelworks_Listener;

extern CORBA::StaticTypeInfo *_marshaller_Steelworks_IDLConsts;

extern CORBA::StaticTypeInfo *_marshaller__seq_Steelworks_Ring;

extern CORBA::StaticTypeInfo *_marshaller__seq_Steelworks_Stack;

#endif

---