nocorbatrace.h

Go to the documentation of this file.

#ifndef _CORBATRACE_H
#define _CORBATRACE_H

#include <cstring>
#include <string>
#include <vector>

#include <cstdio>


//#define _CORBATRACE_DEBUG

namespace CORBA {
        char* string_dup(const char* s);
}

namespace Steelworks {

        struct Ring {
                long no;
                long reqNumber;

                Ring():no(0),reqNumber(0) {}
                Ring(const Ring& r) {
                        no = r.no;
                        reqNumber = r.reqNumber;
                }
        };
        typedef std::vector<Ring> RingSet;

        struct Stack {
                long x, y;
                double height;
                double maxDiameter;
                RingSet rings;

                Stack():x(0),y(0),height(0.0),maxDiameter(0.0) {}
                Stack(const Stack& s) {
                        x = s.x;
                        y = s.y;
                        height = s.height;
                        maxDiameter = s.maxDiameter;
                        rings = s.rings;
                }
        };
        typedef std::vector<Stack> StackSet;

        struct Pallet {
                long number;
                StackSet stacks;

                Pallet():number(0){}
                Pallet(const Pallet& p) {
                        number = p.number;
                        stacks = p.stacks;
                }
        };

        namespace IDLConsts {
                // Kranpositionen
                static const long CRANE_POS_UNLOAD           = 0;
                static const long CRANE_POS_OVEN             = 1;
                static const long CRANE_POS_BATH             = 2;
                static const long CRANE_POS_STORAGE          = 3;
                static const long CRANE_POS_TRANSMISSION     = 4;

                // Kransubpositionen
                static const long CRANE_SUBPOS_STORE_PLACE_1 = 1;
                static const long CRANE_SUBPOS_STORE_PLACE_2 = 2;
                static const long CRANE_SUBPOS_STORE_PLACE_3 = 3;
                static const long CRANE_SUBPOS_FAN_PLACE     = 4;
                static const long CRANE_SUBPOS_POLYMER_BATH  = 5;
                static const long CRANE_SUBPOS_WATER_BATH    = 6;

                // Palettenpositionen
                static const long PAL_POS_CRANE              = 0;
                static const long PAL_POS_OVEN               = 1;
                static const long PAL_POS_BATH               = 2;
                static const long PAL_POS_STORAGE            = 3;
                static const long PAL_POS_TRANSMISSION       = 4;
                static const long PAL_POS_BIGSTORAGE         = 5;
                static const long PAL_POS_HARDNESSTEST       = 6;

                // Palettensubpositionen
                static const long PAL_SUBPOS_STORE_PLACE_1   = 1;
                static const long PAL_SUBPOS_STORE_PLACE_2   = 2;
                static const long PAL_SUBPOS_STORE_PLACE_3   = 3;
                static const long PAL_SUBPOS_FAN_PLACE       = 4;
                static const long PAL_SUBPOS_POLYMER_BATH    = 5;
                static const long PAL_SUBPOS_WATER_BATH      = 6;


                // Vehiclepositionen
                static const long VEHICLE_POS_ROW1           = 0;
                static const long VEHICLE_POS_ROW2           = 1;
                static const long VEHICLE_POS_ROW3           = 2;
                static const long VEHICLE_POS_ROW4           = 3;
                static const long VEHICLE_POS_UNLOAD         = 4;

                // Luftkuehlzustaende
                static const long STORAGE_EMPTY              = 0;
                static const long STORAGE_PARKING            = 1;
                static const long STORAGE_AIRCOOLING         = 2;
                static const long STORAGE_VENTILATOR         = 3;               
        };

        struct Request {
                Request() {}
                Request(const Request& r) {*this = r;}
                Request& operator=(const Request& r) {
                        number = r.number;
                        startTime = strdup(r.startTime);
                        treatment = strdup(r.treatment);
                        steelType = strdup(r.steelType);
                        numberOfRings = r.numberOfRings;
                        diameter = r.diameter;
                        height = r.height;
                        weight = r.weight;
                        numberOfRings = r.numberOfRings;
                        comment = strdup(r.comment);
                }

                ~Request() {
                        if (startTime!=0) free(startTime);
                        if (treatment!=0) free(treatment);
                        if (steelType!=0) free(steelType);
                        if (comment!=0) free(comment);
                }

                long number;
                char* startTime;
                char* treatment;
                char* steelType;
                long numberOfRings;
                double diameter;
                double height;
                double weight;
                char* comment;
        };
}

class ListenerWrapper{
        ListenerWrapper* remote;
        ListenerWrapper():remote(0){}

        friend ListenerWrapper* listener();
        public:
        static void initialize(){}

        void factorySetState(bool state){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->factorySetState(state);
                else printf("factory set state to %s\n",state?"works":"does not work");
#endif
        }

        void newRequest(const Steelworks::Request& req) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->newRequest(req);
                else printf("new request %d %s %s %s %d\n", req.number, req.startTime, req.treatment, req.steelType, req.numberOfRings);
#endif
                printf(".");
        }

        void doneRequest(long number, const char* endTime) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->doneRequest(number, endTime);
                else printf("done request %d %s\n", number, endTime);
#endif
                printf(".");
        }

        void setNumberOfRings(long reqNumber, long newNumber) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->setNumberOfRings(reqNumber, newNumber);
                else printf("set number of rings %d %d\n", reqNumber, newNumber);
#endif
                printf(".");
        }


        void doneRing(long reqNumber) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->doneRing(reqNumber);
                else printf("done ring %d\n", reqNumber);
#endif
                printf(".");
        }

        void moveVehicle(long number,long newPosition){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->moveVehicle(number,newPosition);
                else printf("move vehicle %d %d\n",number,newPosition);
#endif
        }

        void shift(long numberOfRow) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->shift(numberOfRow);
                else printf("row %d shifted", numberOfRow);
#endif
                printf(".");
        }

        void newPallet(const Steelworks::Pallet& p){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->newPallet(p);
                else printf("new pallet %d\n", p.number);
#endif
                printf(".");
        }

        void movePallet(long number, long newPosition){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->movePallet(number,newPosition);
                else printf("move pallet %d %d\n",number,newPosition);
#endif
        }

        void palletChangesOwner(long palletNumber, long newOwner, long newSubOwner){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->palletChangesOwner(palletNumber, newOwner, newSubOwner);
                else printf("palletChangesOwner %d-%d-%d\n", palletNumber, newOwner, newSubOwner);
#endif
        }

        void deletePallet(long number){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->deletePallet(number);
                else printf("delete pallet %d\n",number);
#endif
                printf(".");
        }

        void craneSetState(bool moves){
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->craneSetState(moves);
                else printf("crane set state to %s\n",moves?"moves":"does not move");
#endif
        }

        void craneMoveTo(long newPosition, long subPosition) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->craneMoveTo(newPosition, subPosition);
                else printf("crane moves to position %d-%d\n", newPosition, subPosition);
#endif
                printf(".");
        }

//      void craneGetsPallet(long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->craneGetsPallet(palletNumber);
//              else printf("crane gets pallet %d\n", palletNumber);
//#endif
//              printf(".");
//      }

        void ovenSetState(long number, long newState){
#ifdef _CORBATRACE_DEBUG
                if (remote)
                        remote->ovenSetState(number,newState);
                else
                        printf("oven set state %d %d\n",number,newState);
#endif
                printf(".");
        }

        void storageSetState(long storageNumber, long state) {
#ifdef _CORBATRACE_DEBUG
                if (remote)
                        remote->storageSetState(storageNumber, state);
                else
                        printf("set storage %d to state %d\n", storageNumber, state);
#endif
                printf(".");
        }

//      void ovenGetsPallet(long ovenNumber, long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->ovenGetsPallet(ovenNumber, palletNumber);
//              else printf("oven %d gets pallet %d\n", ovenNumber, palletNumber);
//#endif
//              printf(".");
//      }

//      void bathGetsPallet(long bathNumber, long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->bathGetsPallet(bathNumber, palletNumber);
//              else printf("bath %d gets pallet %d\n", bathNumber, palletNumber);
//#endif
//              printf(".");
//      }

//      void storageGetsPallet(long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->storageGetsPallet(palletNumber);
//              else printf("storage gets pallet %d\n", palletNumber);
//#endif
//              printf(".");
//      }

//      void transmissionGetsPallet(long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->transmissionGetsPallet(palletNumber);
//              else printf("transmission gets pallet %d\n", palletNumber);
//#endif
//              printf(".");
//      }

        void transmissionMoveTo(long position) {
#ifdef _CORBATRACE_DEBUG
                if (remote) remote->transmissionMoveTo(position);
                else printf("transmission moves to %d\n", position);
#endif
                printf(".");
        }

//      void bigStorageGetsPallet(long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->bigStorageGetsPallet(palletNumber);
//              else printf("bigStorage gets pallet %d\n", palletNumber);
//#endif
//              printf(".");
//      }

//      void hardnessTestPlaceGetsPallet(long palletNumber) {
//#ifdef _CORBATRACE_DEBUG
//              if (remote) remote->hardnessTestPlaceGetsPallet(palletNumber);
//              else printf("hardnessTestPlace gets pallet %d\n", palletNumber);
//#endif
//              printf(".");
//      }

        void setTime(const char* time){
#ifdef _CORBATRACE_DEBUG
                if (remote)
                        remote->setTime(time);
                else
                        printf("set time %s\n",time);
#endif
                printf(".");
        }

        void setDay(long day){
#ifdef _CORBATRACE_DEBUG
                if (remote)
                        remote->setDay(day);
                else
                        printf("set day %d\n",day);
#endif
        }

        void stop() {
#ifdef _CORBATRACE_DEBUG
                if (remote)
                        remote->stop();
                else
                        printf("simulation finsihed");
#endif
                printf(".");
        }
};

inline ListenerWrapper *listener(){
        static ListenerWrapper li;
        return &li;
}

#endif

---