template <class EVENT_T> class CEventConsumerManager
{
   void RegisterEventId(unsigned long);
   void Connect();
   void Push(Eventdata);
};

template <class EVENT_T> void CEventConsumerManager< EVENT_T > ::RegisterEventID(unsigned long EventID) 
{
    m_EventID_Vec.push_back( EventID );
}

template <class EVENT_T> void CEventConsumerManager< EVENT_T >::Connect() 
{
    // Melde Dich beim Eventservice für alle ID's an...
    // Ist Implementiert und funktioniert
}

template <class EVENT_T> void CEventConsumerManager< EVENT_T >::push(const RtecEventComm::EventSet& data) throw( CORBA::SystemException ) 
{
      // Hier bekomme ich die Events vom CORBA Eventservice
      // Ich könnte über E.header.source herausfinden auf welcher ID empfangen wurde

      EVENT_T *pEventData; 

      if( ( E.data.any_value >>= pEventData ) == 0 )
      {
        std::cout << "Wrong data" << std::endl;
        continue;
      }                                        

      std::cout << "Correct data" << std::endl;

      // Hier rufe ich beim Benutzer meiner Klasse die push auf, um die Daten weiter zu reichen
      if( m_pEventConsumerClient )
      {
        m_pEventConsumerClient->push( *pEventData );
      }

    }
}

Der oben erwähnte Code funktioniert. Als Benutzer meiner Template-Klasse kann man sich für mehrere Kanäle (ID's) anmelden, und wird bei Empfang auf den jeweiligen ID's der Daten über Push benachrichtigt. Dies funktioniert allerdings nur für einen Datentypen (EVENT_T).

Ich möchte nun, dass man sich mit einem ConsumerManager Objekt für x Datentypen auf y EventId's einschreiben kann.

Das ich X Datentypen angeben kann, würde ich über Typelists realisieren. Mein Problem ist nun die Zuordnung von Templateparameter (Datentyp) zu ID.

Kleines Beispiel (wie ich es mir wünschen würde):

CEventConsumerManager< AMPEL_E, MODUS_T, STATUS_S > myManager;

    // ...
    myManager.RegisterEventID(1); // <-- Wie ordne ich diesem Kanal dem Ampel Enum zu?
    myManager.RegisterEventID(20); // <-- z.B. Kanal für MODUS_T typen

    // ...

   myManager.Connect();

nun möchte ich in meiner CEventConsumerManager< >::push Methode gerne folgendes machen:

if( E.header.source == ID OF EVENT_T)
      {
           EVENT_T *pEventData; 
           if( ( E.data.any_value >>= pEventData ) == 0 )
           //...
      }
      if(E.header.source == ID OF EVENT_2_T)
      {
        EVENT_2_T *pEventData; 
        if( ( E.data.any_value >>= pEventData ) == 0 )
        //...

      }

Ich hoffe ihr versteht was ich meine...

Hat jemand eine Idee?

Meine Frage, wie mache ich die Zuordnung von ID zu Datentypen in meinem Template bekannt?

Was spricht gegen einen normalen Observer ansatz? Ob du Typen oder Messages hast, ist ja egal.

Wenn du nur ein Value2Type haben willst, das geht einfach:

template<int V>
struct Value2Type;

template<>
struct Value2Type<1> {
  typedef EVENT_A type;
};

template<>
struct Value2Type<2> {
  typedef EVENT_B type;
};

wobei ich nicht ganz verstehe was du jetzt eigentlich willst. du hast teilweise statische elemente, wie eben diese typlist - willst dann aber woanders über IDs arbeiten - ergo dynamisch.

Ich erhalte in meiner Klasse auf einer ID die Werte im CORBA Datentyp any und wollte es dem Benutzer sparen sich mit der Konvertierung des any Types zu beschäftigen. Der Benutzer meiner Klasse hat die Zuordnung zwischen ID und Typen, die ich so gerne hätte...

Ich bin gerade dabei eine CORBA Anbindung (wiederverwendbar und projektunabhängig) zu schreiben. Die ganzen ORB Zugriffe, narrow- Befehle, Naming_Service Anbindung, etc. habe ich weit gekapselt bekommen, das jemand eine CORBA Anwendung schreiben kann, der gar kein CORBA kennt sondern nur c++.

Beim Event Service bin ich momentan am scheitern. Die Sendeseite (Eventsupplier) habe ich schon ganz gut hinbekommen, allerdings ist das Problem die Empfängerseite.

Beim Eventservice kann man einen Consumer über Filter mehrere Kanal-ID's zuweisen. Ich bekomme dann in meiner Template-Klasse EventConsumerManager in meine push Methode alle Events vom Eventservice, für die ich mich eingeschrieben habe.

Ich bräuchte eigentlich sowas wie eine Map, die Typen und ID's speichern kann. Sowas gibt's aber nicht.

Ich glaube, dass ich nicht drum herum komme, die Events als allgemeinen Typen (CORBA any, boost any, void*), zusammen mit der Info auf welchem Kanal die Daten kamen, an den Nutzer meiner Klasse weiterzureichen.

Dann kann der Nutzer die Daten in den jeweiligen Typen zurück konvertieren.

// in push von EventConsumerManager
    if( m_pEventConsumerClient )
    {
        m_pEventConsumerClient->push( E.data.any_value, E.header.source);
    }

Solltet ihr noch eine bessere variante haben, lasst es mich wissen.

Gruß Paddy

Paddy82 schrieb:

Ich bräuchte eigentlich sowas wie eine Map, die Typen und ID's speichern kann. Sowas gibt's aber nicht.

naja den typ koenntest du eventuell mittels RTTI als string speichern.
hab leider von CORBA null ahnung, weshalb ich aoch nicht ganz genau weiß was da da eigendlich genau damit meinst.
koenntest du eventuell ein minimales beispiel schreiben, wo man sieht was du genau machen willst ?

Meep Meep

template <class EVENT_T> void CEventConsumerManager< EVENT_T >::push(const RtecEventComm::EventSet& data) throw( CORBA::SystemException ) 
{ 
      // Hier bekomme ich die Events vom CORBA Eventservice 
      // Ich könnte über E.header.source herausfinden auf welcher ID empfangen wurde 

      EVENT_T *pEventData; 

      if( ( E.data.any_value >>= pEventData ) == 0 ) 
      { 
        std::cout << "Wrong data" << std::endl; 
        continue; 
      }                                         

      std::cout << "Correct data" << std::endl; 

      // Hier rufe ich beim Benutzer meiner Klasse die push auf, um die Daten weiter zu reichen 
      if( m_pEventConsumerClient ) 
      { 
        m_pEventConsumerClient->push( *pEventData ); 
      } 

    } 
}

Als Pseudo-Code müsste es in etwa so aussehen:

template <class EVENT_T, EVENT_2_T, ...> void CEventConsumerManager< EVENT_T, EVENT_2_T, ... >::push(const RtecEventComm::EventSet& data) throw( CORBA::SystemException ) 
{
   // hier steht drin, auf welcher Kanal-ID dieser Event übertragen wurde...
   switch(data.header.source)
   {
       // Hier muss ich nachschlagen was für welche angelegt werden soll
       case m_vecOfID_s[0]:
       {
           EVENT_T *pEventData; 
           if( ( data.data.any_value >>= pEventData ) == 0 )
           {
                m_pEventConsumerClient->push( *pEventData );
           }
           break;
       }
       case m_vecOfID_s[1]:
       {
           EVENT_2_T *pEventData; 
           if( ( data.data.any_value >>= pEventData ) == 0 )
           {
                m_pEventConsumerClient->push( *pEventData );
           }
           break;
       }
   }
}

Der Vektor m_vecOfID_s wird durch die RegisterEventID-Methode gefüllt (siehe oben).

Sind die IDs die den Typen entsprechen schon zur Compiletime bekannt? Wenn ja, dann wäre eine ID2Type Struktur, wie Shade vorgeschlagen hat, ein guter Weg.
Etwas komfortabler könnte man es machen indem man eine Typliste benutzt und die Position in dieser der ID entsprechen würde (vorausgesetzt das geht mit den Corba IDs überhaupt).

Ansonsten schau dir mal die boost::mpl an die kann dir deine Arbeit auf jeden Fall erleichtern.

Nun müssen im push der Benutzers je nach id in die jeweiligen Datentypen konvertiert werden.

Der Nutzer muss zwar konvertieren, allerdings braucht er dann keine template's mehr benutzen.