3dpcp/.svn/pristine/30/306410b8f38b27f016a128d70b0f94461c6ad30a.svn-base
2012-09-16 14:33:11 +02:00

192 lines
6.2 KiB
Text

/**
* @file
* @brief Clientside command structure for client-server interaction.
*
* @author Thomas Escher
*/
#ifndef SCANSERVER_CLIENTINTERFACE_H
#define SCANSERVER_CLIENTINTERFACE_H
// segment manager, allocators, containers, pointers, mutexes ...
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <boost/interprocess/sync/interprocess_condition.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/offset_ptr.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/string.hpp>
// hide the boost namespace and shorten others
namespace
{
namespace ip = boost::interprocess;
// the segment manager providing the allocations
typedef ip::managed_shared_memory::segment_manager SegmentManager;
}
// allocator and type for a shared string
typedef ip::allocator<char, SegmentManager> CharAllocator;
typedef ip::basic_string<char, std::char_traits<char>, CharAllocator> SharedString;
#include "scanserver/sharedScan.h"
#include "scanserver/cache/cacheObject.h"
//! TEST: Pod message type
enum message_t {
MESSAGE_NONE = 0,
MESSAGE_STOP,
MESSAGE_READ_DIRECTORY,
MESSAGE_LOAD_CACHE_OBJECT,
MESSAGE_ALLOCATE_CACHE_OBJECT,
MESSAGE_INVALIDATE_CACHE_OBJECT,
MESSAGE_GET_POSE,
MESSAGE_ADD_FRAME,
MESSAGE_LOAD_FRAMES_FILE,
MESSAGE_SAVE_FRAMES_FILE,
MESSAGE_CLEAR_FRAMES,
MESSAGE_GET_CACHE_SIZE,
MESSAGE_PRINT_METRICS
};
/**
* @brief Clientside communication for the scanserver management.
*
* This is the main class visible in clients, relaying all calls to the server via shared memory. Access can be obtained via create and subsequent calls to getInstance.
* All calls to the server are put into a message type and its arguments written to interprocess containers for transfer to the server.
* The ServerInterface derives this class to share the mutexes and arguments and hides the server functionality from the client. This also splits up compilation between the client and server parts.
*/
class ClientInterface {
protected:
//! The segment manager used for creating new objects with construct<>
ip::offset_ptr<SegmentManager> segment_manager;
//! Void allocator to use for ip-STL-containers
ip::allocator<void, SegmentManager> allocator;
//! Mutex for concurrent access to the client interface, protecting the server communication and argument manipulation
ip::interprocess_mutex m_mutex_client;
//! Mutex for client-server communication, handling the process switch and work on the server
ip::interprocess_mutex m_mutex_server;
//! Condition the server waits on and the client notifies to
ip::interprocess_condition m_condition_server;
//! Condition the clients will wait on while the server processes
ip::interprocess_condition m_condition_client;
//! TEST: Pod message type
message_t m_message;
//! String arguments for message passing
SharedString m_arg_string_1, m_arg_string_2;
//! Integer arguments for message passing
unsigned int m_arg_uint_1, m_arg_uint_2;
//! size_t argument for >4GB sizes
std::size_t m_arg_size_t;
//! Float arguments for message passing
float m_arg_float_1, m_arg_float_2;
//! IO type argument for message passing
IOType m_arg_io_type;
//! An error message containing detais
SharedString m_error_message;
//! Pointer for a scanvector
ip::offset_ptr<SharedScanVector> m_scanvector_ptr;
//! Pointer for a scan
ip::offset_ptr<SharedScan> m_sharedscan_ptr;
//! Pointer for a cache object
ip::offset_ptr<CacheObject> m_cacheobject_ptr;
// TODO: remove this later on, this is for close for the testclient
public:
// private:
//! internal message sending
void sendMessage(message_t message);
public:
//! Add and read a directory into the scan vector, ownership: client
SharedScanVector* readDirectory(const char* dir_path, IOType type = UOS, unsigned int start = 0, unsigned int end = -1);
//! "Close" a directory by releasing all contained scans, deleting the vector and resetting the pointer
void closeDirectory(SharedScanVector*& scans);
//! Called from SharedScan on a cache miss, this requests the serverside cache handler to load, returns false if no cached file was found
bool loadCacheObject(CacheObject* obj);
//! Called from SharedScan, request enough memory to hold reduced points
void allocateCacheObject(CacheObject* obj, unsigned int size);
//! Called from SharedScan, let the CacheManager invalide a CacheObject
void invalidateCacheObject(CacheObject* obj);
//! Called from SharedScan, requests the pose
void getPose(SharedScan* scan);
//! Called from SharedScan, requests a frame and writes into it
void addFrame(SharedScan* scan, double* transformation, unsigned int type);
//! Called from SharedScan, requests loading frames saved in the file
void loadFramesFile(SharedScan* scan);
//! Called from SharedScan, requests saving frames into a file
void saveFramesFile(SharedScan* scan);
//! Called from SharedScan, this removes all previous contained frames
void clearFrames(SharedScan* scan);
//! Returns the CacheObject shared memory size for allocation and planning purposes
std::size_t getCacheSize();
//! Let the server print out its metric
void printMetrics();
protected:
//! Trivial constructor: initialize all shared memory containers, only allowed to be called by the ServerInterface
ClientInterface(SegmentManager* sm) :
segment_manager(sm),
allocator(sm),
m_message(MESSAGE_NONE),
m_arg_string_1(allocator),
m_arg_string_2(allocator),
m_error_message(allocator)
{
}
// only the instance in the server will deconstruct
virtual ~ClientInterface()
{
}
protected:
//! The one shared memory opened in the application, a single one in each of the clients and in the server
static ip::managed_shared_memory* m_msm;
private:
//! Client singleton for easy global access in the whole application
static ClientInterface* m_singleton;
public:
//! Opens the shared memory and sets the singleton in a client process
static ClientInterface* create();
//! Closes the shared memory
static void destroy();
//! Returns the singleton instance
static ClientInterface* getInstance();
};
#endif //SCANSERVER_CLIENTINTERFACE_H