//--------------------------------------------------------------------------
bool VeFilePath::TestPath(const VeChar8* pcPath, PathInfo& kOutput) noexcept
{
# ifdef VE_PLATFORM_WIN
_finddata_t kData;
VeSizeT stHandle = _findfirst(pcPath, &kData);
if (stHandle != VE_ELF)
{
kOutput.m_stAttrib = kData.attrib & 0xf0;
kOutput.m_stLastModTime = kData.time_write;
return true;
}
# else
struct stat kBuf;
if (VE_SUCCEEDED(lstat(pcPath, &kBuf)))
{
kOutput.m_stAttrib = 0;
if(S_ISREG(kBuf.st_mode))
kOutput.m_stAttrib |= VE_A_ARCH;
if(S_ISDIR(kBuf.st_mode))
kOutput.m_stAttrib |= VE_A_SUBDIR;
kOutput.m_stLastModTime = kBuf.st_mtime;
return true;
}
# endif
return false;
}
//--------------------------------------------------------------------------
bool VeJoinThread(VeThreadHandle hThread) noexcept
{
#ifdef BUILD_PLATFORM_WIN
return WaitForSingleObject(hThread, UINT32_MAX) == WAIT_OBJECT_0;
#else
return hThread ? VE_SUCCEEDED(pthread_join(hThread, NULL)) : true;
#endif
}
//--------------------------------------------------------------------------
bool VeJoinThread(VeThreadHandle hThread)
{
#if defined(VE_PLATFORM_WIN) || defined(VE_PLATFORM_MOBILE_SIM)
return WaitForSingleObject(hThread, VE_INFINITE) == WAIT_OBJECT_0;
#else
return hThread ? VE_SUCCEEDED(pthread_join(hThread, NULL)) : true;
#endif
}
//--------------------------------------------------------------------------
void VeFilePath::FindFileList(const VeChar8* pcDesc,
VeVector<VeFixedString>& kOut) const noexcept
{
# ifdef VE_PLATFORM_WIN
VeChar8 acBuffer[VE_MAX_PATH_LEN];
PATH_CAT(acBuffer, m_kPath, pcDesc);
_finddata_t kData;
VeSizeT stHandle = _findfirst(acBuffer, &kData);
if (stHandle != VE_ELF)
{
do
{
if ((kData.attrib & 0xf0) == _A_ARCH)
{
kOut.push_back(kData.name);
}
} while (VE_SUCCEEDED(_findnext(stHandle, &kData)));
VE_ASSERT_EQ(_findclose(stHandle), VE_S_OK);
}
# else
const VeChar8* pcFile = VeStrrchr(pcDesc, '/');
pcFile = pcFile ? (pcFile + 1) : pcDesc;
DIR* pkDir(nullptr);
if (pcFile == pcDesc)
{
pkDir = opendir(m_kPath.GetLength() ? m_kPath : ".");
}
else
{
VeChar8 acBuffer[VE_MAX_PATH_LEN];
VeChar8* pcTemp = acBuffer;
if (m_kPath.GetLength())
{
pcTemp += VeSprintf(acBuffer, "%s/", m_kPath.GetStr());
}
VeStrncpy(pcTemp, VE_MAX_PATH_LEN, pcDesc, pcFile - pcDesc - 1);
pkDir = opendir(acBuffer);
}
if (pkDir)
{
struct dirent* pkEntry;
while ((pkEntry = readdir(pkDir)))
{
if (pkEntry->d_type != DT_DIR)
{
if (VeWildNameMatch(pkEntry->d_name, pcFile))
{
kOut.push_back(pkEntry->d_name);
}
}
}
VE_ASSERT_EQ(closedir(pkDir), VE_S_OK);
}
# endif
}
void* memalign(VeSizeT stAlignment, VeSizeT stByteSize)
{
void* pvPointer(NULL);
if(VE_SUCCEEDED(posix_memalign(&pvPointer, stAlignment, stByteSize)))
{
return pvPointer;
}
else
{
return NULL;
}
}
//--------------------------------------------------------------------------
VeUInt32 PropertySContainer::UpdateProperties()
{
if(m_kDBDirty.Size())
{
VeUInt32 u32Res = m_pkParent->GetDBBusiness()->Update(this);
if(VE_SUCCEEDED(u32Res))
{
m_kDBDirty.Clear();
m_kDBNode.Detach();
}
return u32Res;
}
else
{
return VE_S_OK;
}
}
//--------------------------------------------------------------------------
VeImagePtr VeImage::CreateImage(VeUInt64 u64CheckHead,
VeBinaryIStream& kStream)
{
VeImagePtr spRes;
if(VE_SUCCEEDED(png_sig_cmp((png_const_bytep)&u64CheckHead, 0, 8)))
{
spRes = VE_NEW VePNGImage;
}
else
{
}
if(spRes)
{
kStream >> (*spRes);
}
return spRes;
}
//--------------------------------------------------------------------------
VeFilePath::ReadTask::ReadTask(const VeChar8* pcFullPath,
VeRefNode<ReadCallback>& kCallback) noexcept
: m_kFullPath(pcFullPath)
{
IncRefCount();
m_kNode.m_Content = this;
ve_sys.Collect(m_kNode);
m_kCallback.attach_back(kCallback);
m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept
{
if (VE_SUCCEEDED(VeAccess(m_kFullPath, ACCESS_R_OK)))
{
FILE* pkFile(nullptr);
# ifdef VE_PLATFORM_WIN
fopen_s(&pkFile, m_kFullPath, "rb");
# else
pkFile = fopen(m_kFullPath, "rb");
# endif
if (pkFile)
{
fseek(pkFile, 0, SEEK_END);
VeSizeT stLen = ftell(pkFile);
fseek(pkFile, 0, SEEK_SET);
VeBlobPtr spBlob = VE_NEW VeBlob(stLen);
VeSizeT stRead = fread(spBlob->GetBuffer(), 1, stLen, pkFile);
fclose(pkFile);
if (stRead == stLen)
{
m_spData = VE_NEW VeMemoryIStream(spBlob);
}
}
}
m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept
{
for (auto call : m_kCallback)
{
call(m_spData);
}
DecRefCount();
};
kMgr.AddFGTask(m_kTask);
};
ve_res_mgr.GetTaskQueue(VeResourceManager::TASK_FILE).AddBGTask(m_kTask);
}
//--------------------------------------------------------------------------
VeFileIStream::VeFileIStream(const VeChar8* pcFileName,
VeSizeT stCache) noexcept : m_stCacheSize(stCache)
{
if (VE_SUCCEEDED(VeAccess(pcFileName, VeDirectory::ACCESS_F_OK)))
{
# ifdef VE_PLATFORM_WIN
fopen_s(&m_pkFile, pcFileName, "rb");
# else
m_pkFile = fopen(pcFileName, "rb");
# endif
if (m_pkFile)
{
UpdateLenth();
VE_ASSERT(m_stCacheSize);
m_pbyCache = VeAlloc(VeByte, m_stCacheSize);
VE_ASSERT(m_pbyCache);
return;
}
}
SetError(true);
}
//--------------------------------------------------------------------------
VeResult VeAssetIStream::Seek(VePtrDiff pdOffset, VeWhence eWhence) noexcept
{
return VE_SUCCEEDED(AAsset_seek(m_pkAsset, pdOffset, eWhence))
? VE_S_OK : VE_E_FAIL;
}
//--------------------------------------------------------------------------
bool VeFilePath::CreatePath(const VeChar8* pcPath) noexcept
{
VeSizeT stLen = VeStrlen(pcPath);
VeChar8 acBuffer[VE_MAX_PATH_LEN];
VeMemoryCopy(acBuffer, pcPath, stLen + 1);
VeChar8* pcTemp = acBuffer;
if ((*pcTemp) == '/') ++pcTemp;
VeChar8* pcEnd = acBuffer + stLen;
bool bAllowCreate(false);
while (pcTemp < pcEnd)
{
while (true)
{
if ((*pcTemp) == '\0')
{
break;
}
if ((*pcTemp) == '/' || (*pcTemp) == '\\')
{
(*pcTemp) = 0;
break;
}
else
{
++pcTemp;
}
}
if (VE_SUCCEEDED(VeAccess(acBuffer, 2)))
{
bAllowCreate = true;
if (pcTemp < pcEnd)
{
(*pcTemp) = '/';
++pcTemp;
}
}
else if (VE_SUCCEEDED(VeAccess(acBuffer, 0)))
{
bAllowCreate = false;
if (pcTemp < pcEnd)
{
(*pcTemp) = '/';
++pcTemp;
}
}
else if (bAllowCreate)
{
if (VE_SUCCEEDED(VeMkDir(acBuffer)))
{
if (pcTemp < pcEnd)
{
(*pcTemp) = '/';
++pcTemp;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
return true;
}
//--------------------------------------------------------------------------
bool VeFilePath::Access(VeUInt32 u32Flag) const noexcept
{
return VE_SUCCEEDED(VeAccess(m_kPath, u32Flag));
}
