[C++] enum waarden en scope

[H!GHGuY]

Voor zij die heel vertrouwd zijn met enums, usings, typedefs, Koenig lookup en name imports, kunnen het verhaaltje skippen en naar beneden doorscrollen

Om de dependencies binnen framework modules te verkleinen ben ik bezig om deze op te splitsen in de core en enkele dependencies die dan mbv compiler opties ingeschakeld kunnen worden afhankelijk van het project.

1 van die dependencies is die op omniORB, een CORBA (GIOP) implementatie. Enkele van de framework modules kunnen RPC-calls afhandelen binnen de eigen module. Aangezien we het framework geen design kunnen laten opleggen aan de applicatie die het gebruikt (1 grote interface, meerdere kleine, inheritance, ...)
wil ik enige flexibiliteit inbouwen.

Daarom kom ik op zo'n code snippet:

IDL:

// Interface.idl
// Deze IDL definieert enkel de structures en de methodes. Geen modules of interfaces, die komen in
// het applicatie-specifieke deel, welke deze file include (voorbeeld volgt)
struct XYZ { int x; int y; int z; }
enum Kleur { Groen, Geel, Blauw };

void SetKleur(in Kleur kleur);
void SetXYZ(in XYZ xyz);

C++:

// Interface.h
// Hier maak ik een namespace met een vaste naam waarin ik alle structures en types importeer.
// Door de MODULE en INTERFACE argumenten kan ik zo los van de implementatie werken.
#define DECLARE_IDL_INTERFACE(MODULE, INTERFACE) \
namespace InterfaceIDL \
{ \
  using MODULE::INTERFACE::XYZ; \
  /// enum??
}

// Interface_impl.h
// Hier implementeer ik dan de server-side calls en deze spreken dan de core van de framework module aan.
virtual void SetXYZ(InterfaceIDL::XYZ xyz)
{
  // implementatie
}
virtual void SetKleur(InterfaceIDL::Kleur kleur)
{
  // implementatie
}

Een applicatie zou zich moeten beperken tot:

IDL:

module MyModule
{
  interface MyInterface {
     // een include in IDL is equivalent aan een C++ include.
     #include "Interface.idl"
  }
}

Waarmee omniidl, de IDL => C++ mapper, de volgende C++ code genereert:

C++:

namespace Module
{
  class Interface
  {
  public:
    struct XYZ { int x; int y; int z; };
    enum Kleur { Groen, Geel, Blauw };

    virtual void SetKleur(Kleur kleur) = 0;
    virtual void SetXYZ(XYZ xyz) = 0;
  };
};

Van deze interface moet de applicatie dan afleiden om ze te implementeren:

C++:

// MyInterface.h
#include "Interface.h"

DECLARE_IDL_INTERFACE(MyModule, MyInterface);

class MyInterface
{
  public:
    #include "Interface_impl.h"
};

Vraag: Het schoentje wringt nu bij die enum.
Gegeven dat die enum als <namespace>::<class>::<enum> gedefinieerd is, wil ik de enum en alle enum waardes aanspreekbaar maken vanuit die eigen gedefinieerde namespace:

C++:

/* verkort */ OtherNamespace::OtherClass::EnumX { EnumX_Waarde1; }

namespace MyNamespace
{
  using namespace OtherNamespace; //doet niets
  using OtherNamespace::OtherClass::EnumX; // fout want EnumX is geen type direct binnen een namespace
  typedef EnumX OtherNamespace::OtherClass::EnumX; // de enum waardes zijn niet bruikbaar
  // ???
};

void X(MyNamespace::EnumX enumx)
{
  if (enumx == MyNameSpace::EnumX_Waarde1)
    return;
  else
    //...
}

Hoe importeer ik die namen?

[.oisyn]

Kan niet.

Ok, langer antwoord . Ze staan in een class, en die kun je niet 'usen'. Je kunt ze hoogstens wrappen. Een typedef voor de type, en static consts voor de enum waarden. Die zul je helaas stuk voor stuk moeten definieren.

[ Voor 92% gewijzigd door .oisyn op 13-04-2009 23:02 ]

[H!GHGuY]

Daar vreesde ik al voor...