//---------------------------------------------------------------------------------------------------------------------
VSpline VSplinePath::GetSpline(qint32 index) const
{
if (Count()<1)
{
throw VException(tr("Not enough points to create the spline."));
}
if (index < 1 || index > Count())
{
throw VException(tr("This spline does not exist."));
}
VSpline spl(path.at(index-1).P(), path.at(index).P(), path.at(index-1).Angle2(), path.at(index).Angle1(),
path.at(index-1).KAsm2(), path.at(index).KAsm1(), this->kCurve);
return spl;
}
//---------------------------------------------------------------------------------------------------------------------
QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3,
QPointF &spl2p2, QPointF &spl2p3) const
{
if (Count() < 2)
{
throw VException(tr("Can't cut spline path with one point"));
}
//Always need return two spline paths, so we must correct wrong length.
qreal fullLength = GetLength();
if (length < fullLength * 0.02)
{
length = fullLength * 0.02;
}
else if ( length > fullLength * 0.98)
{
length = fullLength * 0.98;
}
fullLength = 0;
for (qint32 i = 1; i <= Count(); ++i)
{
VSpline spl = VSpline(path.at(i-1).P(), path.at(i).P(), path.at(i-1).Angle2(), path.at(i).Angle1(),
path.at(i-1).KAsm2(), path.at(i).KAsm1(), kCurve);
fullLength += spl.GetLength();
if (fullLength > length)
{
p1 = i-1;
p2 = i;
return spl.CutSpline(length - (fullLength - spl.GetLength()), spl1p2, spl1p3, spl2p2, spl2p3);
}
}
return QPointF();
}
VFSize VFSNode::size() const {
VFSNodeInfo info;
bool nodeExists = this->_platform_getNodeInfo(info);
if (!nodeExists)
throw VException(VSystemError(info.mErrNo), VSTRING_FORMAT("VFSNode::size failed for '%s'.", mPath.chars()));
return info.mFileSize;
}
VInstant VFSNode::modificationDate() const {
VFSNodeInfo info;
bool nodeExists = this->_platform_getNodeInfo(info);
if (!nodeExists)
throw VException(VSystemError(info.mErrNo), VSTRING_FORMAT("VFSNode::modificationDate failed for '%s'.", mPath.chars()));
return VInstant::instantFromRawValue(info.mModificationDate);
}
// static
VString VSocket::_platform_addrinfoToIPAddressString(const VString& hostName, const struct addrinfo* info) {
void* addr;
if (info->ai_family == AF_INET) {
addr = (void*) &(((struct sockaddr_in*)info->ai_addr)->sin_addr);
} else if (info->ai_family == AF_INET6) {
addr = (void*) &(((struct sockaddr_in6*)info->ai_addr)->sin6_addr);
} else {
// We don't know how to access the addr for other family types. They could conceivably be added.
throw VException(VSTRING_FORMAT("VSocket::_platform_addrinfoToIPAddressString(%s): An invalid family (%d) other than AF_INET or AF_INET6 was specified.", hostName.chars(), info->ai_family));
}
VString result;
result.preflight(MAX_ADDRSTRLEN);
const char* buf = ::inet_ntop(info->ai_family, addr, result.buffer(), MAX_ADDRSTRLEN);
if (buf == NULL) {
throw VException(VSystemError::getSocketError(), VSTRING_FORMAT("VSocket::_platform_addrinfoToIPAddressString(%s): inet_ntop() failed.", hostName.chars()));
}
result.postflight((int) ::strlen(buf));
return result;
}
// static
void VFSNode::copyDirectory(const VFSNode& source, const VFSNode& dest, bool recursive) {
if (recursive) {
VString sourcePathWithTrailingSeparator = source.getPath() + (source.getPath().endsWith(PATH_SEPARATOR_CHAR) ? "" : PATH_SEPARATOR_CHARS);
if (dest.getPath().startsWith(sourcePathWithTrailingSeparator)) {
throw VException(VSTRING_FORMAT("Attempt to recursively copy '%s' into '%s'.", source.getPath().chars(), dest.getPath().chars()));
}
}
if (!dest.exists()) {
dest.mkdirs();
}
VFSNodeCopyDirectoryCallback copyDirectoryCallback(dest, recursive);
source.iterate(copyDirectoryCallback);
}
//---------------------------------------------------------------------------------------------------------------------
VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePointPosition pos) const
{
if (indexSpline < 1 || indexSpline > Count())
{
throw VException(tr("This spline does not exist."));
}
if (pos == SplinePointPosition::FirstPoint)
{
return path.at(indexSpline-1);
}
else
{
return path.at(indexSpline);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VSplinePath::UpdatePoint(qint32 indexSpline, const SplinePointPosition &pos, const VSplinePoint &point)
{
if (indexSpline < 1 || indexSpline > Count())
{
throw VException(tr("This spline does not exist."));
}
if (pos == SplinePointPosition::FirstPoint)
{
path[indexSpline-1] = point;
}
else
{
path[indexSpline] = point;
}
}
void VFSNode::_platform_directoryIterate(VDirectoryIterationCallback& callback) const {
VString nodeName;
DIR* dir = ::opendir(mPath);
if (dir == NULL) {
throw VException(VSTRING_FORMAT("VFSNode::_platform_getDirectoryList failed for directory '%s'.", mPath.chars()));
}
try {
bool keepGoing = true;
struct dirent* entry = ::readdir(dir);
while (keepGoing && (entry != NULL)) {
VThread::yield(); // be nice if we're iterating over a huge directory
nodeName.copyFromCString(entry->d_name);
// Skip current and parent pseudo-entries. Otherwise client must
// know too much detail in order to avoid traversal problems.
if ((nodeName != ".") &&
(nodeName != "..")) {
VFSNode childNode;
this->getChildNode(nodeName, childNode);
keepGoing = callback.handleNextNode(childNode);
}
entry = ::readdir(dir);
}
} catch (...) {
::closedir(dir);
throw;
}
::closedir(dir);
}
void VFSNode::_platform_renameNode(const VString& newPath) const {
int result = VFileSystem::rename(mPath, newPath);
if (result != 0)
throw VException(VSystemError(), VSTRING_FORMAT("VFSNode::_platform_renameNode failed with result %d renaming '%s' to '%s'.", result, mPath.chars(), newPath.chars()));
}
void VFSNode::_platform_createDirectory() const {
int result = VFileSystem::mkdir(mPath, (S_IFDIR | S_IRWXO | S_IRWXG | S_IRWXU));
if (result != 0)
throw VException(VSystemError(), VSTRING_FORMAT("VFSNode::_platform_createDirectory failed with result %d for '%s'.", result, mPath.chars()));
}
// static
void VFSNode::safelyOverwriteFile(const VFSNode& target, Vs64 dataLength, VBinaryIOStream& dataStream, bool keepOld) {
bool success = true;
VString errorMessage;
VString targetFileName = target.getName();
VInstant now;
VString temporaryFileName = now.getLocalString(VFSNODE_SAFE_FILE_NAME_INSTANT_FORMATTER) + "_tmp_" + targetFileName;
VString keptFileName = now.getLocalString(VFSNODE_SAFE_FILE_NAME_INSTANT_FORMATTER) + "_ver_" + targetFileName;
VFSNode directoryNode;
target.getParentNode(directoryNode);
VFSNode originalTargetNode(target);
VFSNode temporaryFileNode(directoryNode, temporaryFileName);
VFSNode keptFileNode(directoryNode, keptFileName);
// Create and write to the temp file within a scope block to ensure file is closed when scope is exited.
/* stream scope */ {
VBufferedFileStream tempFileStream(temporaryFileNode);
VBinaryIOStream tempOutputStream(tempFileStream);
try {
tempFileStream.openWrite();
} catch (const VException& ex) {
success = false;
errorMessage = VSTRING_FORMAT("Unable to open temporary file '%s': %s", target.getPath().chars(), ex.what());
}
if (success) {
try {
VStream::streamCopy(dataStream, tempOutputStream, dataLength);
tempOutputStream.flush();
} catch (const VException& ex) {
success = false;
errorMessage = VSTRING_FORMAT("Unable to write to temporary file '%s': %s", target.getPath().chars(), ex.what());
}
}
}
/*
If we succeeded, delete or rename the original file, and rename the temporary file to the original location.
If we failed, delete the temporary file.
Do this itself in separate phases, so that if the delete/rename fails, we still delete the temporary file.
*/
// 1. Remove target. (It might not exist yet.)
if (success && target.exists()) {
if (keepOld) {
try {
target.renameToNode(keptFileNode);
} catch (const VException& ex) {
success = false;
errorMessage = VSTRING_FORMAT("Failed renaming '%s' to '%s': %s", target.getPath().chars(), keptFileNode.getPath().chars(), ex.what());
}
} else {
if (! target.rm()) {
success = false;
errorMessage = VSTRING_FORMAT("Unable to remove target file '%s'.", target.getPath().chars());
}
}
}
// 2. Rename temporary to (original) target.
if (success) {
try {
temporaryFileNode.renameToNode(originalTargetNode);
} catch (const VException& ex) {
success = false;
errorMessage = VSTRING_FORMAT("Failed renaming '%s' to '%s': %s", temporaryFileNode.getPath().chars(), originalTargetNode.getPath().chars(), ex.what());
}
}
// 3. Remove temporary if unsuccessful.
if (! success) {
if (! temporaryFileNode.rm()) {
errorMessage += VSTRING_FORMAT(" Removal of temporary file '%s' failed.", temporaryFileNode.getPath().chars());
}
}
// If we failed, throw an exception with the error message we built wherever we encountered errors.
if (! success) {
throw VException(errorMessage);
}
}