void python_export_filesystem(py::module &m) {
using namespace fs;
py::module fs_module =
m.def_submodule("filesystem", "Cross-platform filesystem support");
py::class_<path> path_class(fs_module, "path");
path_class
.def(py::init<>())
.def(py::init<const path &>())
.def(py::init<const std::string &>())
.def("__len__", &path::length)
.def("file_size", &path::file_size)
.def("empty", &path::empty)
.def("is_absolute", &path::is_absolute)
.def("make_absolute", &path::make_absolute)
.def("exists", &path::exists)
.def("is_directory", &path::is_directory)
.def("is_file", &path::is_file)
.def("extension", &path::extension)
.def("parent_path", &path::parent_path)
.def("remove_file", &path::remove_file)
.def("resize_file", &path::resize_file)
.def("str", [](const path &p) { return p.str(); })
.def("str", [](const path &p, path::path_type t) { return p.str(t); })
.def("set", [](path &p, const std::string &v, path::path_type t) { p.set(v, t); })
.def("set", [](path &p, const std::string &v) { p.set(v); })
.def(py::self / py::self)
.def("__repr__", [](const path &p) { return p.str(); })
.def_static("getcwd", &path::getcwd);
py::enum_<path::path_type>(path_class, "path_type")
.value("windows_path", path::windows_path)
.value("posix_path", path::posix_path)
.value("native_path", path::native_path)
.export_values();
py::class_<resolver>(fs_module, "resolver")
.def(py::init<>())
.def("__len__", &resolver::size)
.def("append", &resolver::append)
.def("prepend", &resolver::prepend)
.def("resolve", &resolver::resolve)
.def("__getitem__", [](const resolver &r, size_t i) {
if (i >= r.size())
throw py::index_error();
return r[i];
})
.def("__setitem__", [](resolver &r, size_t i, path &v) {
if (i >= r.size())
throw py::index_error();
r[i] = v;
})
.def("__delitem__", [](resolver &r, size_t i) {
if (i >= r.size())
throw py::index_error();
r.erase(r.begin() + i);
})
.def("__repr__", [](const resolver &r) {
std::ostringstream oss;
oss << r;
return oss.str();
});
py::class_<MemoryMappedFile>(fs_module, "MemoryMappedFile")
.def(py::init<fs::path, size_t>())
.def(py::init<fs::path, bool>())
.def(py::init<fs::path>())
.def("resize", &MemoryMappedFile::resize)
.def("__repr__", &MemoryMappedFile::toString)
.def("size", &MemoryMappedFile::size)
.def("filename", &MemoryMappedFile::filename)
.def("readOnly", &MemoryMappedFile::readOnly)
.def_static("createTemporary", &MemoryMappedFile::createTemporary)
.def_buffer([](MemoryMappedFile &m) -> py::buffer_info {
return py::buffer_info(
m.data(),
sizeof(uint8_t),
py::format_descriptor<uint8_t>::format(),
1,
{ (size_t) m.size() },
{ sizeof(uint8_t) }
);
});
py::implicitly_convertible<std::string, path>();
}
