iframe-proxy | Sunbelt Computer Software

History

210 lines (187 loc) · 6.69 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

//////////////////////////////////////////////////////////////////////////////

// (C) Copyright Ion Gaztanaga 2004-2012. Distributed under the Boost

// Software License, Version 1.0. (See accompanying file

// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// See http://www.boost.org/libs/interprocess for documentation.

//////////////////////////////////////////////////////////////////////////////

#include <ios> //std::streamoff

#include <fstream> //std::ofstream, std::ifstream

#include <iostream>

#include <boost/interprocess/file_mapping.hpp>

#include <boost/interprocess/mapped_region.hpp>

#include <boost/container/vector.hpp>

#include <stdexcept> //std::exception

#include <cstddef> //std::size_t

#include "get_process_id_name.hpp"

using namespace boost::interprocess;

file_mapping get_file_mapping()

{

file_mapping f;

return file_mapping(boost::move(f));

}

int main ()

{

BOOST_INTERPROCESS_TRY{

const std::size_t FileSize = 99999*2;

{

std::ofstream file(get_filename().c_str(), std::ios::binary | std::ios::trunc);

}

{

//Create an empty file mapping

file_mapping mapping(get_filename().c_str(), read_write);

//Obtain zero file size

offset_t filesize = 5;

if(!mapping.get_size(filesize) || filesize != 0)

return 1;

//Check mapping of empty file does not work

bool thrown = false;

BOOST_INTERPROCESS_TRY{

mapped_region region (mapping, read_write);

}

BOOST_INTERPROCESS_CATCH(...){

thrown = true;

} BOOST_INTERPROCESS_CATCH_END

if(!thrown)

return file_mapping().swap(mapping), file_mapping::remove(get_filename().c_str()), 1;

thrown = false;

BOOST_INTERPROCESS_TRY{

mapped_region region (mapping, read_only);

}

BOOST_INTERPROCESS_CATCH(...){

thrown = true;

} BOOST_INTERPROCESS_CATCH_END

if(!thrown)

return file_mapping().swap(mapping), file_mapping::remove(get_filename().c_str()), 1;

}

file_mapping::remove(get_filename().c_str());

}

{

//Create file with given size

std::ofstream file(get_filename().c_str(), std::ios::binary | std::ios::trunc);

file.seekp(static_cast<std::streamoff>(FileSize-1));

file.write("", 1);

}

{

//Create a file mapping

file_mapping mapping(get_filename().c_str(), read_write);

//Create two mapped regions, one half of the file each

mapped_region region (mapping

,read_write

,FileSize/2

);

mapped_region region2(mapping

,read_write

,FileSize/2

,FileSize - FileSize/2

);

//Fill two regions with a pattern

unsigned char *filler = static_cast<unsigned char*>(region.get_address());

for(std::size_t i = 0

;i < FileSize/2

;++i){

*filler++ = static_cast<unsigned char>(i);

}

filler = static_cast<unsigned char*>(region2.get_address());

for(std::size_t i = FileSize/2

;i < FileSize

;++i){

*filler++ = static_cast<unsigned char>(i);

}

if(!region.flush(0, 0, false)){

return 1;

}

if(!region2.flush(0, 0, true)){

return 1;

}

//See if the pattern is correct in the file

{

//Open the file

std::ifstream file(get_filename().c_str(), std::ios::binary);

//Create a memory buffer

boost::container::vector<unsigned char> memory(FileSize/2 +1);

//Fill buffer

file.read(static_cast<char*>(static_cast<void*>(memory.data()))

, FileSize/2);

unsigned char *checker = memory.data();

//Check pattern

for(std::size_t i = 0

;i < FileSize/2

;++i){

if(*checker++ != static_cast<unsigned char>(i)){

return 1;

}

//Fill buffer

file.read(static_cast<char*>(static_cast<void*>(memory.data()))

, FileSize - FileSize/2);

checker = memory.data();

//Check pattern

for(std::size_t i = FileSize/2

;i < FileSize

;++i){

if(*checker++ != static_cast<unsigned char>(i)){

return 1;

}

//Now check the pattern mapping a single read only mapped_region

{

//Create a file mapping

file_mapping mapping(get_filename().c_str(), read_only);

//Create a single regions, mapping all the file

mapped_region region (mapping

,read_only

);

//Check pattern

unsigned char *pattern = static_cast<unsigned char*>(region.get_address());

for(std::size_t i = 0

;i < FileSize

;++i, ++pattern){

if(*pattern != static_cast<unsigned char>(i)){

return 1;

}

#ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES

{

//Create a file mapping

file_mapping mapping(get_wfilename().c_str(), read_only);

//Create a single regions, mapping all the file

mapped_region region (mapping

,read_only

);

//Check pattern

unsigned char *pattern = static_cast<unsigned char*>(region.get_address());

for(std::size_t i = 0

;i < FileSize

;++i, ++pattern){

if(*pattern != static_cast<unsigned char>(i)){

return 1;

}

#endif //BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES

{

//Now test move semantics

file_mapping mapping(get_filename().c_str(), read_only);

file_mapping move_ctor(boost::move(mapping));

file_mapping move_assign;

move_assign = boost::move(move_ctor);

mapping.swap(move_assign);

file_mapping ret(get_file_mapping());

}

BOOST_INTERPROCESS_CATCH(std::exception &exc){

file_mapping::remove(get_filename().c_str());

std::cout << "Unexpected Exception: " << exc.what() << std::endl;

BOOST_INTERPROCESS_RETHROW

} BOOST_INTERPROCESS_CATCH_END

file_mapping::remove(get_filename().c_str());

return 0;

}

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

file_mapping_test.cpp

Latest commit

History

file_mapping_test.cpp

File metadata and controls