LocalhostConnection.cpp

Go to the documentation of this file.

#include <rms/provider/LocalhostConnection.h>

namespace gov {

namespace fnal {

namespace cd {

namespace rms {

namespace provider {

/**
 * Create a new LocalhostConnection.
 *
 * @param applicationName The name of the application generating/receiving
 * messages.
 * @param applicationPartition The partition of the application that is
 * generating/receiving messages.  
 */
LocalhostConnection::LocalhostConnection(const std::string applicationName,
                                         const int applicationPartition) {
    _messageSource.setProperty(base::RmsDestination::TARGET_PROPERTY_NAME, applicationName);
    _messageSource.setPartitionProperty(applicationPartition);

    char hostname[32];
    if (gethostname(hostname, 31) == 0) {
        _uuidGenerator = new util::UUIDGenerator(hostname);
    }
    else {
        _uuidGenerator = new util::UUIDGenerator("C++LocalhostConnection");
    }
}

/**
 * Determine whether this provider supports a particular destination.
 *
 * @return True as this provider supports all destinations.
 */
bool LocalhostConnection::supportsDestination(const base::RmsDestination& candidateDestination) { 
    return true; 
}

/**
 * Send a string to a particular destination.
 *
 * @param dest The destination to send a message to.
 * @param messageString The string to send.
 */
void LocalhostConnection::sendString(const base::RmsDestination& dest, 
                                     const std::string& messageString) {
    ListenerContainer aListener;
    boost::shared_ptr<std::string> messagePtr (new std::string(messageString));

    for (unsigned int i = 0; i < _destinationList.size(); i++) {
        aListener.setDestination(_destinationList.at(i).getDestination());
        aListener.setListener(_destinationList.at(i).getListener());

        if (aListener.getDestination().equals(dest)) {
            aListener.getListener()->textReceived(messagePtr);
        }
    }
}

/**
 * Send an RmsMessage to a particular destination.
 *
 * @param dest The destination to send a message to.
 * @param message The RmsMessage to send.
 */
void LocalhostConnection::sendMessage(const base::RmsDestination &dest,
                                      const base::RmsMessage& message) {
    sendString(dest, message.serialize());
}

/**
 * Register a listener with this provider.
 *
 * @param dest The destination that the listener is interested in
 * @param listener A reference to the listener object.
 */
void LocalhostConnection::addListener(const base::RmsDestination& dest, 
                                      ProviderListener *listener) {
    ListenerContainer newListener(dest, listener);

    _destinationList.push_back(newListener);
}

/**
 * Remove a listener from this provider.
 *
 * @param dest The destination to remove.
 * @param listener The listener to remove.
 *
 * @bug implement
 */
void LocalhostConnection::removeListener(const base::RmsDestination& dest, ProviderListener *listener) {
    return;
}

/**
 * Ping a destination to see if it is up.
 *
 * @return This always returns true.
 */
bool LocalhostConnection::ping(const base::RmsDestination& pingDestination) {
    return true;
}

/**
 * Close this provider, and free any resources it may have allocated.
 */
void LocalhostConnection::close() {
    return;
}
  
}  // end of namespace provider

}  // end of namespace rms

}  // end of namespace cd

}  // end of namespace fnal

}  // end of namespace gov