Is there a way to typedef a static function

Question

I have a Singleton class to have only one single instance of my MPIProxy class (as it otherwise would result in to many constructions).

To create the single MPIProxy class I have the following typedef:

typedef Singleton<MPIProxy_> MPIProxySingleton;

However to access the instance I need the following code:

int myrank = MPIProxySingleton::instance().getRank();

I would prefer to have allow the clients to write instead of MPIProxySingleton::instance().xy() simply MPIProxy.xy(). Where .xy is a function of the MPIProxy_ class. Such that the code above would look like:

int myrank = MPIProxy.getRank();

I have tried the follwing:

typedef MPIProxySingleton::instance() MPIProxy;

However this result in compile errors:

/Users/david/Desktop/GSOC/miind/miind/./libs/MPILib/include/utilities/MPIProxy.hpp:158:31: error: C++ requires a type specifier for all declarations
typedef Singleton<MPIProxy_>::instance() MPIProxy;
~~~~~~~                       ^
/Users/david/Desktop/GSOC/miind/miind/./libs/MPILib/include/utilities/MPIProxy.hpp:158:41: error: expected ';' after top level declarator
typedef Singleton<MPIProxy_>::instance() MPIProxy;

Here is the code of my Singleton class:

/** Singleton holder template class.
 * Template class to create singletons. A singleton instance of class
 * MyType is created and accessed using
 * \code
 * typedef Singleton<MyType> MySingletonType;
 * MyType& myRef = MySingletonType::instance()
 * // ... do something ...
 * \endcode
 */
template<class T>
class Singleton
{
public:
    // disallow creation, copying and assignment

    /** Deleted constructor to disallow explicit construction.
     * Is not defined.
     */
    Singleton()=delete;

    /** Deleted copy constructor to disallow explicit copying.
     * Is not defined.
     * @param S A singleton object.
     */
    Singleton(const Singleton& S)=delete;

    /** Deleted assignment operator to disallow explicit assignment.
     * @param S A singleton object.
     * @return The current singleton.
     */
    Singleton& operator=(const Singleton& S)=delete;

    /** Return a reference to the only instance of \c Singleton<T>.
     * @return A reference to the instance of the object.
     */
    static T& instance();

    /** Destructor.
     */
    ~Singleton();

private:


    /** Create method. Creates the singleton instance (a Meyers singleton, ie.
     * a function static object) upon the first call to \c instance().
     */
    static void create();

    /** Pointer to the instance.
     */
    static T* pInstance_;

    /** Status of the singleton. True if the singleton was destroyed.
     */
    static bool destroyed_;

};

/** Returns the unique instance of class T. If it was already
 *  deleted an exception is thrown. If the class T was never used
 *  before a new instance is generated.
 *
 * @return Unique instance of class T
 */
template<class T> T& Singleton<T>::instance()
{
    if (!pInstance_) {
        if (destroyed_) {
            // dead reference
            throw Exception("The instance was already destroyed");
        } else {
            // initial creation
            create();
        }
    }
    return *pInstance_;
}

template<class T> Singleton<T>::~Singleton()
{
    pInstance_ = 0;
    destroyed_ = true;
}

template<class T> void Singleton<T>::create()
{
    static T theInstance;
    pInstance_ = &theInstance;
}

template<class T> T* Singleton<T>::pInstance_ = 0;
template<class T> bool Singleton<T>::destroyed_ = false;

And here the header of my MPIProxy_ class

class MPIProxy_ {
public:
    /**
     * destructor
     */
    virtual ~MPIProxy_();

    /**
     * wrapper method to return the process id, if mpi is disabled it returns 0
     * @return the world rank of a process
     */
    int getRank() const;

    /**
     * wrapper method to return the size, if MPI is disabled it returns 1
     * @return
     */
    int getSize() const;

    /**
     * wrapper for mpi barrier
     */
    void barrier();

    /**
     * waits until all request stored in the vector _mpiStatus are finished
     */
    void waitAll();

    /**
     * Broadcast the value from root
     * @param value The value to be broadcast
     * @param root The root process
     */
    template<typename T>
    void broadcast(T& value, int root);

    /**
     * asynchronous receive operation the mpi status is stored in _mpiStatus
     * @param source The source of the message
     * @param tag The tag of the message
     * @param value The value received
     */
    template<typename T>
    void irecv(int source, int tag, T& value) const;

    /**
     * asynchronous send operation the mpi status is stored in _mpiStatus
     * @param dest The destination of the message
     * @param tag The tag of the message
     * @param value The value sended
     */
    template<typename T>
    void isend(int dest, int tag, const T& value) const;


private:
    /**
     * Declare the Singleton class a friend to allow construction of the MPIProxy_ class
     */
    friend class Singleton<MPIProxy_>;
    /**
     * constructor sets the MPI rank and size
     */
    MPIProxy_();

#ifdef ENABLE_MPI
    /**
     * stores the mpi statuses
     */
    static std::vector<boost::mpi::request> _mpiStatus;
#endif

    /**
     * storage of the rank to avoid function calls
     */
    static int _rank;

    /**
     * storage of the size to avoid function calls
     */
    static int _size;
};

template<typename T>
void MPIProxy_::broadcast(T& value, int root) {
#ifdef ENABLE_MPI
    mpi::communicator world;
    boost::mpi::broadcast(world, value, root);
#endif
}

template<typename T>
void MPIProxy_::irecv(int source, int tag, T& value) const {
#ifdef ENABLE_MPI
    mpi::communicator world;
    _mpiStatus.push_back(world.irecv(source, tag, value));
#else
    MPILib::utilities::Exception("MPI Code called from serial code in irecv");
#endif
}

template<typename T>
void MPIProxy_::isend(int dest, int tag, const T& value) const {
#ifdef ENABLE_MPI
    mpi::communicator world;
    _mpiStatus.push_back(world.isend(dest, tag, value));
#else
    MPILib::utilities::Exception("MPI Code called from serial code in isend");
#endif
}

typedef Singleton<MPIProxy_> MPIProxySingleton;
//typedef MPIProxySingleton::instance() MPIProxy;

Answer 1

I just wanted to present a slightly different way of accomplishing the same thing. Since a Singleton is supposed to be stateless, there is actually no harm in allowing the Singleton be instantiated or copied or assigned or destroyed. It is just a wrapper for the single static instance of the template parameter. Given that, you could define your Singleton this way:

template <typename T>
class Singleton {
public:
    static T & instance () {
        static T instance_;
        return instance_;
    }
    T * operator -> () const { return &instance(); }
};

So, for the object you intend to make a Singleton:

class Foo_ {
    friend class Singleton<Foo_>;
    Foo_ () {}
public:
    void bar () { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

typedef Singleton<Foo_> Foo;

And then, you can use it like this:

Foo()->bar();

Answer 2

Wrapper functions are always a good option in such cases:

MPIProxy_ &  MPIProxy()
{
   return MPIProxySingleton::instance();
}

Then use it as:

MPIProxy().xy();

Answer 3

Make a reference to it:

MPIProxy_& MPIProxy = MPIProxySingleton::instance();