//
|
// Created by ps on 8/9/18.
|
//
|
|
#ifndef SYNCDBTOOL_SHAREMEMORYTOOL_HPP
|
#define SYNCDBTOOL_SHAREMEMORYTOOL_HPP
|
|
|
#include <boost/interprocess/managed_shared_memory.hpp>
|
#include <boost/interprocess/allocators/allocator.hpp>
|
#include <boost/interprocess/containers/string.hpp>
|
#include <boost/interprocess/containers/vector.hpp>
|
#include <boost/interprocess/containers/map.hpp>
|
#include <mutex>
|
#include <iostream>
|
|
//#include "SyncDB.hpp"
|
|
namespace BISTL {
|
|
using boost::interprocess::managed_shared_memory;
|
using boost::interprocess::shared_memory_object;
|
using boost::interprocess::create_only;
|
using boost::interprocess::open_only;
|
using boost::interprocess::open_read_only;
|
using boost::interprocess::open_or_create;
|
using boost::interprocess::open_copy_on_write;
|
|
using boost::interprocess::allocator;
|
//DataType
|
using boost::interprocess::basic_string;
|
using boost::interprocess::vector;
|
using boost::interprocess::map;
|
|
typedef managed_shared_memory::segment_manager segment_manager_t;
|
|
typedef allocator<void, segment_manager_t> void_allocator;
|
|
//vector<int>
|
typedef allocator<int, segment_manager_t> int_allocator;
|
typedef vector<int, int_allocator> int_vector;
|
|
//vector<vector<int>>
|
typedef allocator<int_vector, segment_manager_t> int_vector_allocator;
|
typedef vector<int_vector, int_vector_allocator> int_vector_vector;
|
|
//std::string
|
typedef allocator<char, segment_manager_t> char_allocator;
|
typedef basic_string<char, std::char_traits<char>, char_allocator> char_string;
|
|
typedef std::lock_guard<std::mutex> LockG;
|
|
/***
|
* 创建共享内存
|
* @param shm_Name 名称
|
* @param size 大小
|
* @param type 类型
|
* @return managed_shared_memory
|
*/
|
static managed_shared_memory
|
createSHM(std::string &message, std::string shm_Name, std::size_t size = 4096, int type = 1) {
|
try {
|
switch (type) {
|
case 1:
|
return managed_shared_memory(create_only, shm_Name.c_str(), size * 1024);
|
case 2:
|
return managed_shared_memory(open_only, shm_Name.c_str());
|
case 3:
|
return managed_shared_memory(open_read_only, shm_Name.c_str());
|
case 4:
|
return managed_shared_memory(open_or_create, shm_Name.c_str(), size * 1024);
|
case 5:
|
return managed_shared_memory(open_copy_on_write, shm_Name.c_str());
|
default:
|
//ERR
|
message = "type is error ";
|
// return managed_shared_memory(create_only, shm_Name.c_str(), size);
|
}
|
} catch (std::exception ex) {
|
message = ex.what();
|
}
|
// return ;
|
}
|
|
//shanchu shm
|
/***
|
* 删除共享内存
|
* @param shm_Name 名称
|
* @return 状态
|
*/
|
static bool removeSHM(std::string shm_Name) {
|
return shared_memory_object::remove(shm_Name.c_str());
|
}
|
|
struct Feature_Info {
|
public:
|
Feature_Info(const char *id, const char *feature, const char *create_by,
|
const char *create_time, const char *update_time,
|
const void_allocator &void_alloc) :
|
m_id(id, void_alloc), m_feature(feature, void_alloc), m_create_by(create_by, void_alloc),
|
m_create_time(create_time, void_alloc), m_update_time(update_time, void_alloc) {}
|
|
~Feature_Info() {}
|
|
char_string m_id;
|
char_string m_feature;
|
char_string m_create_by;
|
char_string m_create_time;
|
char_string m_update_time;
|
};
|
|
//vector<Feature_Info>
|
typedef allocator<Feature_Info, segment_manager_t> Feature_Info_allocator;
|
typedef vector<Feature_Info, Feature_Info_allocator> Feature_Info_vector;
|
|
//map<string,Feature_Info>
|
typedef char_string KeyType;
|
typedef Feature_Info MappedType;
|
typedef std::pair<const KeyType, MappedType> ValueType;
|
typedef allocator<ValueType, segment_manager_t> ShmemAllocator;
|
typedef map<KeyType, MappedType, std::less<char_string>, ShmemAllocator> bi_map_Feature_Info;
|
|
//无用
|
template<class T>
|
class BiMapData {
|
public:
|
BiMapData(std::string shm_Name, std::size_t size)
|
: m_shm_Name(shm_Name), m_size(size * 1024), m_segment(open_or_create, m_shm_Name.c_str(), m_size),
|
m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
|
createMap();
|
}
|
|
BiMapData(std::string shm_Name)
|
: m_shm_Name(shm_Name), m_size(10 * 1024), m_segment(open_only, m_shm_Name.c_str()),
|
m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
|
}
|
|
virtual ~BiMapData() {
|
|
}
|
|
const BISTL::void_allocator *getVoid_allocator() {
|
return &m_alloc_inst;
|
}
|
|
const T *getMap() {
|
return mymap;
|
}
|
|
private:
|
void createMap() {
|
mymap = m_segment.find_or_construct<T>(m_shm_Name.c_str())(
|
std::less<char_string>(), m_alloc_inst);
|
}
|
|
private:
|
std::string m_shm_Name;
|
std::size_t m_size;
|
managed_shared_memory m_segment;
|
|
void_allocator m_alloc_inst;
|
|
T *mymap;
|
std::mutex m_mutex;
|
};
|
|
|
class BiMapFeaData {
|
public:
|
/***
|
* 打开或创建共享内存
|
* @param shm_Name 名称
|
* @param size 大小
|
*/
|
BiMapFeaData(std::string shm_Name, std::size_t size)
|
: m_shm_Name(shm_Name), m_size(size * 1024), m_segment(open_or_create, m_shm_Name.c_str(), m_size),
|
m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
|
createMap_Feature_Info();
|
std::cout << m_segment.get_free_memory() << std::endl;
|
std::cout << m_shm_Name.c_str() << std::endl;
|
}
|
|
/***
|
* 打开共享内存
|
* @param shm_Name 名称
|
*/
|
BiMapFeaData(std::string shm_Name)
|
: m_shm_Name(shm_Name), m_size(10 * 1024), m_segment(open_only, m_shm_Name.c_str()),
|
m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
|
createMap_Feature_Info();
|
std::cout << m_segment.get_free_memory() << std::endl;
|
std::cout << m_shm_Name.c_str() << std::endl;
|
}
|
|
virtual ~BiMapFeaData() {
|
|
}
|
|
/***
|
* 获取一个能够转换为任何allocator<T, segment_manager_t>类型的allocator
|
* @return
|
*/
|
const BISTL::void_allocator *getVoid_allocator() {
|
return &m_alloc_inst;
|
}
|
|
/***
|
* 返回map地址
|
* @return
|
*/
|
const BISTL::bi_map_Feature_Info *getMap() {
|
return mymap;
|
}
|
|
/***
|
* 封装value的初始化操作
|
* @param id
|
* @param feature
|
* @param create_by
|
* @param create_time
|
* @param update_time
|
* @return
|
*/
|
bool saveKeyOrValue(std::string id, std::string feature, std::string create_by, std::string create_time,
|
std::string update_time) {
|
Feature_Info v(id.c_str(), feature.c_str(), create_by.c_str(),
|
create_time.c_str(), update_time.c_str(), m_alloc_inst);
|
char_string key_object(id.c_str(), m_alloc_inst);
|
LockG lock(m_mutex);
|
auto item = mymap->insert(ValueType(key_object, v));
|
return item.second;
|
}
|
|
|
private:
|
/***
|
* 创建相应类型的map
|
*/
|
void createMap_Feature_Info() {
|
mymap = m_segment.find_or_construct<bi_map_Feature_Info>(m_shm_Name.c_str())(
|
std::less<char_string>(), m_alloc_inst);
|
}
|
|
|
private:
|
std::string m_shm_Name;
|
std::size_t m_size;
|
managed_shared_memory m_segment;
|
|
void_allocator m_alloc_inst;
|
|
bi_map_Feature_Info *mymap;
|
std::mutex m_mutex;
|
};
|
|
|
}
|
|
#endif //SYNCDBTOOL_SHAREMEMORYTOOL_HPP
|
