#include <utility>
#include <string>
#include <iostream>
#include <functional>                  
#include <algorithm>

#include <boost/variant.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/smart_ptr/shared_ptr.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>
#include <boost/interprocess/sync/named_condition.hpp>
#include <boost/unordered_map.hpp>     
#include <boost/functional/hash.hpp>   

using namespace boost::interprocess;

typedef managed_shared_memory::allocator<char>::type              char_allocator;
typedef basic_string<char, std::char_traits<char>, char_allocator> shm_string;

typedef shm_string  KeyType;
typedef shm_string  MappedType;
typedef std::pair<const KeyType, MappedType> ValueType;

typedef allocator<ValueType, managed_shared_memory::segment_manager> ShmemAllocator;
typedef boost::unordered_map
< KeyType               , MappedType
  , boost::hash<KeyType>  ,std::equal_to<KeyType>
  , ShmemAllocator>
Hash;

const char * const K_MUTEX_SUFFIX = "__MUTEX";
const char * const K_CONDITION_SUFFIX = "__CONDITION";

std::string MutexName(const std::string segment_name);
std::string ConditionalName(const std::string segment_name);

struct shm_remove
{
  shm_remove(const std::string& segment_name) 
     : segment_name_(segment_name)
  {
    const std::string mutex_name = MutexName(segment_name_);
    const std::string conditional_name = ConditionalName(segment_name_);
    shared_memory_object::remove( segment_name_.c_str() ); 
    boost::interprocess::named_mutex::remove( mutex_name.c_str() );    
    boost::interprocess::named_condition::remove( conditional_name.c_str() );
  }
  ~shm_remove()
  { 
    const std::string mutex_name = MutexName(segment_name_);
    const std::string conditional_name = ConditionalName(segment_name_);
    shared_memory_object::remove( segment_name_.c_str() ); 
    boost::interprocess::named_mutex::remove( mutex_name.c_str() );    
    boost::interprocess::named_condition::remove( conditional_name.c_str() );
  }
  std::string segment_name_;
private:
  // non copyable nor assignable ( could be movable though)
  shm_remove(const shm_remove&);
  shm_remove& operator=(shm_remove);
};

std::string MutexName(const std::string segment_name)
{
  std::stringstream str;
  str << "K_" << segment_name << K_MUTEX_SUFFIX;
  return str.str();
}

std::string ConditionalName(const std::string segment_name)
{
    std::stringstream str;
    str << "K_" << segment_name << K_CONDITION_SUFFIX;
    return str.str();
}

int main()
{
  // 23 + \0
  const std::string key = "NokiaNokiaNokiaNokiaNok";
  const std::string val = "NokiaNokiaNokiaNokiaNok_NokiaNokiaNokiaNokiaNok_NokiaNokiaNokiaNokiaNok_NokiaNokiaNokiaNokiaNok_NokiaNokiaNokiaNokiaNok_NokiaNokiaNokiaNokiaNok";
  
  const std::string segment_name = "test segment numbero uno";
  const std::string mutex_name = MutexName(segment_name);
  const std::string conditional_name = ConditionalName(segment_name);  
  // remove shared memory on construction/destruction  
  shm_remove remover(segment_name);

  // create shared memory
  managed_shared_memory segment(create_only, segment_name.c_str(), 4 * 1024);

  // construct a shared memory hash map
  // note that the first parameter is the initial bucket count and
  // after that, the hash function, the equality function and the allocator
  Hash * h = segment.construct<Hash>("Hash")  //object name
    ( 3, boost::hash<KeyType>(), std::equal_to<KeyType>()                  //
      , segment.get_allocator<ValueType>());                         //allocator instance
  
  char_allocator sa(segment.get_allocator<char>());  
  shm_string shared_key(key.c_str(), sa);
  shm_string shared_val(val.c_str(), sa);
  ValueType vt(shared_key, shared_val);
  h->insert(vt);
  {
    // open_only works regardless of key length
    // open_read_only segfaults at key byte len >= 24
    managed_shared_memory segment(open_read_only, segment_name.c_str());
    char_allocator sa(segment.get_allocator<char>());  
    // SEGFAULT here depending on mode and key length
    shm_string shared_key(key.c_str(), sa);
    Hash::const_iterator i = h->find(shared_key);
    if(h->end() == i)
      {
        std::cerr << "no such key " << key << std::endl;
        return 1;
    }
    const ValueType& vt = *i;
    std::stringstream str;
    str << vt.second;
    std::cout << key << " => " << str.str() << std::endl;
  }
  return 0;
}