Result FileNameToUnixTimeStamp::Convert(const StRef<String> & fileName, /*output*/ Time & timeOfRecord) { if(fileName == NULL || !fileName->len()) return Result::Failure; Result res = Result::Success; std::string stdStr(fileName->cstr()); std::string delimiter1 = "_"; std::string delimiter2 = "."; size_t pos = 0; std::string token; pos = stdStr.rfind(delimiter1); if(pos != std::string::npos) { token = stdStr.substr(0, pos); stdStr.erase(0, pos + delimiter1.length()); pos = stdStr.rfind(delimiter2); if(pos != std::string::npos) { token = stdStr.substr(0, pos); res = strToUint64_safe(token.c_str(), &timeOfRecord); } else { logE_(_func_,"Didn't find '.' symbol in file_name = ", fileName->mem()); res = Result::Failure; } } else { logE_(_func_,"Didn't find '_' symbol in file_name = ", fileName->mem()); res = Result::Failure; } return res; }
mt_throws Result NativeAsyncFile::open (ConstMemory const filename, Uint32 const open_flags, FileAccessMode const access_mode) { int flags = 0; switch ((FileAccessMode::Value) access_mode) { case FileAccessMode::ReadOnly: flags = O_RDONLY; break; case FileAccessMode::WriteOnly: flags = O_WRONLY; break; case FileAccessMode::ReadWrite: flags = O_RDWR; break; default: unreachable (); } if (open_flags && FileOpenFlags::Create) flags |= O_CREAT; // TODO Specify behavior for Truncate & O_RDONLY combination. if (open_flags & FileOpenFlags::Truncate) flags |= O_TRUNC; // TODO Seek to the end of file instead. O_APPEND semantics is too complicated. if (open_flags & FileOpenFlags::Append) flags |= O_APPEND; StRef<String> const filename_str = st_grab (new (std::nothrow) String (filename)); for (;;) { /* NOTE: man 2 open does not mention EINTR as a possible return * value, while man 3 open _does_. This means that EINTR should * be handled for all invocations of open() in MyCpp (and all * over MyNC). */ fd = ::open (filename_str->cstr(), // Note that O_DIRECT affects kernel-level caching/buffering // and should not be set here. flags | O_NONBLOCK, S_IRUSR | S_IWUSR); if (fd == -1) { if (errno == EINTR) continue; if (errno == EAGAIN) { logD_ (_func, "EAGAIN"); break; } if (errno == EWOULDBLOCK) { logD_ (_func, "EWOULDBLOCK"); break; } exc_throw (PosixException, errno); exc_push_ (IoException); return Result::Failure; } break; } return Result::Success; }