Server.h

#ifndef CARMA_CORBA_SERVER_H
#define CARMA_CORBA_SERVER_H

#include "carma/util/Program.h"

#include <memory>
#include <string>

namespace carma {
namespace corba {

    class Client;

    class Server {
    public:

        explicit Server( int argc, char * argv[], int rrtt = 60 );

        virtual ~Server( );

        template< template< typename > class T, typename S >
        void addServant( S & servant,
                         const ::std::string & nameserverName );
        
        template< template< typename > class T , typename S >
        void addServant( S & servant, 
                         typename T< S >::_stub_ptr_type & corbaClientPtr );

        template< typename S, typename N >
        void addNotificationServantFunctor( S & servant, 
                                            const ::std::string & channelName,
                                            const ::std::string & proxyName );

        void work( );

        void run( bool inSeparateThread = false );

        void stop( );
        
        bool terminated( ) const; 

    private:

        friend Client & carma::util::ProgramBase::getCorbaClient();
        Client & client(); 

        // No copy
        Server( const Server & );
        Server & operator=( const Server & );

        // Aggressively hide everything
        struct PrivateImplementation; // Visible to .cc implementation only.
        std::auto_ptr< PrivateImplementation > privateImpl_;
        
        struct PrivateInline; // Visible to .inl templatized implementation 
        std::auto_ptr< PrivateInline > privateInl_; 
    };

}} // namespace carma::corba

// Include the implementation in a separate file to avoid clutter. 
#include "carma/corba/Server.inl"

#endif