dev0/IACore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' of https://git.iasoft.dev/dev0/IACore

Browse Source
This commit is contained in:
Isuru Samarathunga
2025-10-06 00:11:14 +05:30
parent 71f7ff8a85 a73cc7e69c
commit 1815ceb21d
11 changed files with 124 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
Src/IACore/imp/inl/IACore/StreamReader/Interface/StreamReader.interface.inl
View File

@ -16,13 +16,16 @@
#pragma once #pragma once
#include <IACore/Vector.hpp>
#include <IACore/Exception.hpp>
namespace ia namespace ia
{ {
class IStreamReader class IStreamReader
{ {
public: public:
STATIC SharedPtr<IStreamReader> Create(IN PCCHAR filePath); STATIC RefPtr<IStreamReader> Create(IN PCCHAR filePath);
STATIC SharedPtr<IStreamReader> Create(IN Vector<UINT8> &&data); STATIC RefPtr<IStreamReader> Create(IN Vector<UINT8> &&data);
public: public:
PURE_VIRTUAL(BOOL CompareBytes(IN PCUINT8 data, IN INT64 length) CONST); PURE_VIRTUAL(BOOL CompareBytes(IN PCUINT8 data, IN INT64 length) CONST);
@ -44,20 +47,20 @@ namespace ia
class MemoryStreamReader : public IStreamReader class MemoryStreamReader : public IStreamReader
{ {
public: public:
STATIC SharedPtr<IStreamReader> Create(IN Vector<UINT8> &&data); STATIC INLINE RefPtr<IStreamReader> Create(IN Vector<UINT8> &&data);
public: public:
BOOL CompareBytes(IN PCUINT8 data, IN INT64 length) CONST; INLINE BOOL CompareBytes(IN PCUINT8 data, IN INT64 length) CONST;
Vector<UINT8> Read(); INLINE Vector<UINT8> Read();
Vector<UINT8> Read(IN INT64 size); INLINE Vector<UINT8> Read(IN INT64 size);
VOID Read(IN INT64 size, IN PUINT8 buffer); INLINE VOID Read(IN INT64 size, IN PUINT8 buffer);
Vector<UINT8> ReadAndInflate(IN INT64 size); INLINE Vector<UINT8> ReadAndInflate(IN INT64 size);
UINT8 Read8(); INLINE UINT8 Read8();
UINT16 Read16(); INLINE UINT16 Read16();
UINT32 Read32(); INLINE UINT32 Read32();
UINT64 Read64(); INLINE UINT64 Read64();
VOID Skip(IN INT64 size) VOID Skip(IN INT64 size)
{ {
@ -79,28 +82,28 @@ namespace ia
Vector<UINT8> m_buffer; Vector<UINT8> m_buffer;
private: private:
MemoryStreamReader(IN Vector<UINT8> &&data); INLINE MemoryStreamReader(IN Vector<UINT8> &&data);
}; };
class FileStreamReader : public IStreamReader class FileStreamReader : public IStreamReader
{ {
public: public:
STATIC SharedPtr<IStreamReader> Create(IN PCCHAR filePath); STATIC INLINE RefPtr<IStreamReader> Create(IN PCCHAR filePath);
~FileStreamReader(); INLINE ~FileStreamReader();
public: public:
BOOL CompareBytes(IN PCUINT8 data, IN INT64 length) CONST; INLINE BOOL CompareBytes(IN PCUINT8 data, IN INT64 length) CONST;
Vector<UINT8> Read(); INLINE Vector<UINT8> Read();
Vector<UINT8> Read(IN INT64 size); INLINE Vector<UINT8> Read(IN INT64 size);
VOID Read(IN INT64 size, IN PUINT8 buffer); INLINE VOID Read(IN INT64 size, IN PUINT8 buffer);
Vector<UINT8> ReadAndInflate(IN INT64 size); INLINE Vector<UINT8> ReadAndInflate(IN INT64 size);
UINT8 Read8(); INLINE UINT8 Read8();
UINT16 Read16(); INLINE UINT16 Read16();
UINT32 Read32(); INLINE UINT32 Read32();
UINT64 Read64(); INLINE UINT64 Read64();
VOID Skip(IN INT64 size) VOID Skip(IN INT64 size)
{ {
@ -121,15 +124,15 @@ namespace ia
FILE *m_filePtr{}; FILE *m_filePtr{};
private: private:
FileStreamReader(IN PCCHAR filePath); INLINE FileStreamReader(IN PCCHAR filePath);
}; };
SharedPtr<IStreamReader> IStreamReader::Create(IN PCCHAR filePath) INLINE RefPtr<IStreamReader> IStreamReader::Create(IN PCCHAR filePath)
{ {
return FileStreamReader::Create(filePath); return FileStreamReader::Create(filePath);
} }
SharedPtr<IStreamReader> IStreamReader::Create(IN Vector<UINT8> &&data) INLINE RefPtr<IStreamReader> IStreamReader::Create(IN Vector<UINT8> &&data)
{ {
return MemoryStreamReader::Create(std::move(data)); return MemoryStreamReader::Create(std::move(data));
} }

63
Src/IACore/imp/inl/IACore/StreamReader/StreamReader.inl
View File

@ -20,7 +20,7 @@
namespace ia namespace ia
{ {
SharedPtr<IStreamReader> MemoryStreamReader::Create(IN Vector<UINT8> &&data) RefPtr<IStreamReader> MemoryStreamReader::Create(IN Vector<UINT8> &&data)
{ {
struct make_shared_enabler : public MemoryStreamReader struct make_shared_enabler : public MemoryStreamReader
{ {
@ -39,7 +39,7 @@ namespace ia
BOOL MemoryStreamReader::CompareBytes(IN PCUINT8 data, IN INT64 length) const BOOL MemoryStreamReader::CompareBytes(IN PCUINT8 data, IN INT64 length) const
{ {
DXF_ASSERT((m_cursor + length) <= m_buffer.size()); IA_RELEASE_ASSERT((m_cursor + length) <= m_buffer.size());
return !memcmp(&m_buffer[m_cursor], data, length); return !memcmp(&m_buffer[m_cursor], data, length);
} }
@ -61,26 +61,20 @@ namespace ia
VOID MemoryStreamReader::Read(IN INT64 size, IN PUINT8 buffer) VOID MemoryStreamReader::Read(IN INT64 size, IN PUINT8 buffer)
{ {
DXF_ASSERT((m_cursor + size) <= m_buffer.size()); IA_RELEASE_ASSERT((m_cursor + size) <= m_buffer.size());
memcpy_s(buffer, size, &m_buffer[m_cursor], size); memcpy_s(buffer, size, &m_buffer[m_cursor], size);
m_cursor += size; m_cursor += size;
} }
Vector<UINT8> MemoryStreamReader::ReadAndInflate(IN INT64 size)
{
const auto d = Read(size);
return Inflate(d.data(), d.size());
}
UINT8 MemoryStreamReader::Read8() UINT8 MemoryStreamReader::Read8()
{ {
DXF_ASSERT((m_cursor + 1) <= m_buffer.size()); IA_RELEASE_ASSERT((m_cursor + 1) <= m_buffer.size());
return m_buffer[m_cursor++]; return m_buffer[m_cursor++];
} }
UINT16 MemoryStreamReader::Read16() UINT16 MemoryStreamReader::Read16()
{ {
DXF_ASSERT((m_cursor + 2) <= m_buffer.size()); IA_RELEASE_ASSERT((m_cursor + 2) <= m_buffer.size());
const auto r = *reinterpret_cast<UINT16 *>(&m_buffer[m_cursor]); const auto r = *reinterpret_cast<UINT16 *>(&m_buffer[m_cursor]);
m_cursor += 2; m_cursor += 2;
return r; return r;
@ -88,7 +82,7 @@ namespace ia
UINT32 MemoryStreamReader::Read32() UINT32 MemoryStreamReader::Read32()
{ {
DXF_ASSERT((m_cursor + 4) <= m_buffer.size()); IA_RELEASE_ASSERT((m_cursor + 4) <= m_buffer.size());
const auto r = *reinterpret_cast<UINT32 *>(&m_buffer[m_cursor]); const auto r = *reinterpret_cast<UINT32 *>(&m_buffer[m_cursor]);
m_cursor += 4; m_cursor += 4;
return r; return r;
@ -96,7 +90,7 @@ namespace ia
UINT64 MemoryStreamReader::Read64() UINT64 MemoryStreamReader::Read64()
{ {
DXF_ASSERT((m_cursor + 8) <= m_buffer.size()); IA_RELEASE_ASSERT((m_cursor + 8) <= m_buffer.size());
const auto r = *reinterpret_cast<UINT64 *>(&m_buffer[m_cursor]); const auto r = *reinterpret_cast<UINT64 *>(&m_buffer[m_cursor]);
m_cursor += 8; m_cursor += 8;
return r; return r;
@ -105,7 +99,7 @@ namespace ia
namespace ia namespace ia
{ {
SharedPtr<IStreamReader> FileStreamReader::Create(IN PCCHAR filePath) RefPtr<IStreamReader> FileStreamReader::Create(IN PCCHAR filePath)
{ {
struct make_shared_enabler : public FileStreamReader struct make_shared_enabler : public FileStreamReader
{ {
@ -121,7 +115,7 @@ namespace ia
{ {
fopen_s(&m_filePtr, filePath, "rb"); fopen_s(&m_filePtr, filePath, "rb");
if (!m_filePtr) if (!m_filePtr)
throw RuntimeError(BuildString("No such file or directory: ", filePath)); THROW_FILE_OPEN_READ(filePath);
} }
FileStreamReader ::~FileStreamReader() FileStreamReader ::~FileStreamReader()
@ -132,78 +126,71 @@ namespace ia
BOOL FileStreamReader::CompareBytes(IN PCUINT8 data, IN INT64 length) CONST BOOL FileStreamReader::CompareBytes(IN PCUINT8 data, IN INT64 length) CONST
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
STATIC Vector<UINT8> TmpBuffer; STATIC Vector<UINT8> TmpBuffer;
if (TmpBuffer.size() < length) if (TmpBuffer.size() < length)
TmpBuffer.resize(length); TmpBuffer.resize(length);
DXF_RELEASE_ASSERT(fread(TmpBuffer.data(), 1, length, m_filePtr) == length); IA_RELEASE_ASSERT(fread(TmpBuffer.data(), 1, length, m_filePtr) == length);
return !memcmp(TmpBuffer.data(), data, length); return !memcmp(TmpBuffer.data(), data, length);
} }
Vector<UINT8> FileStreamReader::Read() Vector<UINT8> FileStreamReader::Read()
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
Vector<UINT8> result; Vector<UINT8> result;
const auto s = ftell(m_filePtr); const auto s = ftell(m_filePtr);
fseek(m_filePtr, 0, SEEK_END); fseek(m_filePtr, 0, SEEK_END);
const auto e = ftell(m_filePtr); const auto e = ftell(m_filePtr);
fseek(m_filePtr, s, SEEK_SET); fseek(m_filePtr, s, SEEK_SET);
result.resize(e - s); result.resize(e - s);
DXF_RELEASE_ASSERT(fread(result.data(), 1, result.size(), m_filePtr) == result.size()); IA_RELEASE_ASSERT(fread(result.data(), 1, result.size(), m_filePtr) == result.size());
return result; return result;
} }
Vector<UINT8> FileStreamReader::Read(IN INT64 size) Vector<UINT8> FileStreamReader::Read(IN INT64 size)
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
Vector<UINT8> result; Vector<UINT8> result;
result.resize(size); result.resize(size);
DXF_RELEASE_ASSERT(fread(result.data(), 1, size, m_filePtr) == size); IA_RELEASE_ASSERT(fread(result.data(), 1, size, m_filePtr) == size);
return result; return result;
} }
VOID FileStreamReader::Read(IN INT64 size, IN PUINT8 buffer) VOID FileStreamReader::Read(IN INT64 size, IN PUINT8 buffer)
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
DXF_RELEASE_ASSERT(fread(buffer, 1, size, m_filePtr) == size); IA_RELEASE_ASSERT(fread(buffer, 1, size, m_filePtr) == size);
}
Vector<UINT8> FileStreamReader::ReadAndInflate(IN INT64 size)
{
DXF_RELEASE_ASSERT(m_filePtr);
const auto d = Read(size);
return Inflate(d.data(), d.size());
} }
UINT8 FileStreamReader::Read8() UINT8 FileStreamReader::Read8()
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
UINT8 result; UINT8 result;
DXF_RELEASE_ASSERT(fread(&result, 1, 1, m_filePtr) == 1); IA_RELEASE_ASSERT(fread(&result, 1, 1, m_filePtr) == 1);
return result; return result;
} }
UINT16 FileStreamReader::Read16() UINT16 FileStreamReader::Read16()
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
UINT16 result; UINT16 result;
DXF_RELEASE_ASSERT(fread(&result, 2, 1, m_filePtr) == 1); IA_RELEASE_ASSERT(fread(&result, 2, 1, m_filePtr) == 1);
return result; return result;
} }
UINT32 FileStreamReader::Read32() UINT32 FileStreamReader::Read32()
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
UINT32 result; UINT32 result;
DXF_RELEASE_ASSERT(fread(&result, 4, 1, m_filePtr) == 1); IA_RELEASE_ASSERT(fread(&result, 4, 1, m_filePtr) == 1);
return result; return result;
} }
UINT64 FileStreamReader::Read64() UINT64 FileStreamReader::Read64()
{ {
DXF_RELEASE_ASSERT(m_filePtr); IA_RELEASE_ASSERT(m_filePtr);
UINT64 result; UINT64 result;
DXF_RELEASE_ASSERT(fread(&result, 8, 1, m_filePtr) == 1); IA_RELEASE_ASSERT(fread(&result, 8, 1, m_filePtr) == 1);
return result; return result;
} }
} // namespace ia } // namespace ia

2
Src/IACore/imp/inl/IACore/memory/allocator/general.inl
View File

@ -47,7 +47,7 @@ namespace ia
UNUSED(hint); UNUSED(hint);
const size_type size = (sizeof(value_type) * count); const size_type size = (sizeof(value_type) * count);
const auto ptr = reinterpret_cast<size_type>(_ia_malloc(size + alignment + sizeof(PVOID))); const auto ptr = reinterpret_cast<size_type>(_ia_malloc(size + alignment + sizeof(PVOID)));
const auto aligned_ptr = reinterpret_cast<size_type>(ptr + sizeof(PVOID) + alignment - (ptr % alignment)); const auto aligned_ptr = (size_type)(ptr + sizeof(PVOID) + alignment - (ptr % alignment));
*(reinterpret_cast<size_type*>(aligned_ptr-sizeof(PVOID))) = ptr; *(reinterpret_cast<size_type*>(aligned_ptr-sizeof(PVOID))) = ptr;
return reinterpret_cast<pointer_type>(aligned_ptr); return reinterpret_cast<pointer_type>(aligned_ptr);
} }

5
Src/IACore/imp/inl/IACore/stream/interface/stringstream.interface.inl
View File

@ -38,6 +38,11 @@ namespace ia
StringStream& operator<<(IN CONST String& v) { m_impl << v.c_str(); return *this; } StringStream& operator<<(IN CONST String& v) { m_impl << v.c_str(); return *this; }
VOID clear()
{
m_impl.clear();
}
private: private:
std::stringstream m_impl; std::stringstream m_impl;
}; };

6
Src/IACore/imp/inl/IACore/string/string.inl
View File

@ -276,7 +276,11 @@ namespace ia
const auto count = last - first; const auto count = last - first;
res.reserve((count/stride) + 2); res.reserve((count/stride) + 2);
const auto end = start + count + 1; const auto end = start + count + 1;
for(size_type i = start; i < end; i += stride) new (&res.m_data[res.m_count++]) value_type(Base::m_data[i]); for(size_type i = start; i < end; i += stride)
{
new (&res.m_data[res.m_count++]) value_type(Base::m_data[i]);
if(!Base::m_data[i]) break;
}
res.back() = '\0'; res.back() = '\0';
return IA_MOVE(res); return IA_MOVE(res);
} }

20
Src/IACore/inc/hpp/IACore/Definitions.hpp
View File

@ -27,12 +27,6 @@
#include <type_traits> #include <type_traits>
#include <initializer_list> #include <initializer_list>
#if defined (_MSC_VER )
#if !defined(__clang__)
#error "IA software does not support compilation with MSVC. Please use Clang on Windows platforms."
#endif
#endif
#define IAC_SEC_LEVEL(v) (IACORE_SECURITY_LEVEL >= v) #define IAC_SEC_LEVEL(v) (IACORE_SECURITY_LEVEL >= v)
#define IA_DEFINED_TRUE(o) (defined(o) && (o > 0)) #define IA_DEFINED_TRUE(o) (defined(o) && (o > 0))
@ -155,6 +149,20 @@
#define IA_MAX_POSSIBLE_SIZE (static_cast<SIZE_T>(0x7FFFFFFFFFFFF)) #define IA_MAX_POSSIBLE_SIZE (static_cast<SIZE_T>(0x7FFFFFFFFFFFF))
#define IA_MAX_STRING_LENGTH (IA_MAX_POSSIBLE_SIZE >> 8) #define IA_MAX_STRING_LENGTH (IA_MAX_POSSIBLE_SIZE >> 8)
#define IA_VERSION_TYPE UINT64
#define IA_MAKE_VERSION(major, minor, patch) ((static_cast<UINT64>(major) & 0xFFFFFF) << 40) | ((static_cast<UINT64>(minor) & 0xFFFFFF) << 16) | (static_cast<UINT64>(patch) & 0xFFFF)
#if defined(_MSC_VER)
#define IA_DLL_EXPORT __declspec(dllexport)
#define IA_DLL_IMPORT __declspec(dllimport)
#elif defined(__GNUC__)
#define IA_DLL_EXPORT __attribute__((visibility("default")))
#define IA_DLL_IMPORT
#else
#define IA_DLL_EXPORT
#define IA_DLL_IMPORT
#endif
#define __CC_BLACK "\033[30m" #define __CC_BLACK "\033[30m"
#define __CC_RED "\033[31m" #define __CC_RED "\033[31m"
#define __CC_GREEN "\033[32m" #define __CC_GREEN "\033[32m"

6
Src/IACore/inc/hpp/IACore/Exception.hpp
View File

@ -16,7 +16,7 @@
#pragma once #pragma once
#include <IACore/String.hpp> #include <IACore/Logger.hpp>
namespace ia { namespace ia {
enum class ExceptionKind { enum class ExceptionKind {
@ -131,7 +131,9 @@ private:
DO(SECURITY_BYPASS) DO(SECURITY_BYPASS)
#define DEFINE_THROWER(name) \ #define DEFINE_THROWER(name) \
template <typename... Args> NORETURN VOID THROW_##name(Args... args) { \ template <typename... Args> NORETURN VOID THROW_##name(Args... args) { \
throw RuntimeException(ExceptionKind::name, BuildString(args...)); \ const auto msg = BuildString(args...); \
Logger::Error("EXCEPT", "(", #name, "): ", msg); \
throw RuntimeException(ExceptionKind::name, msg); \
} }
FOR_EACH_RUNTIME_EXCEPT_TYPE(DEFINE_THROWER); FOR_EACH_RUNTIME_EXCEPT_TYPE(DEFINE_THROWER);
#undef DEFINE_THROWER #undef DEFINE_THROWER

9
Src/IACore/inc/hpp/IACore/File.hpp
View File

@ -121,10 +121,10 @@ namespace ia
if constexpr (includeExtension) if constexpr (includeExtension)
return path.slice(t + 1, path.end()); return path.slice(t + 1, path.end());
return path.slice(t + 1, path.begin() + (path.rfind('.') - t) - 1); return path.slice(t + 1, path.rfind('.'));
} }
String ExtractDirectoryFromPath(IN CONST String &path) template<BOOL includeTrailingSlash> STATIC String ExtractDirectoryFromPath(IN CONST String &path)
{ {
constexpr char pathDelimiter = '/'; constexpr char pathDelimiter = '/';
@ -132,7 +132,10 @@ namespace ia
if (t == path.end()) if (t == path.end())
return "./"; return "./";
return path.slice(0, t + 1); if CONSTEXPR (includeTrailingSlash)
return path.slice(path.begin(), t + 1);
else
return path.slice(path.begin(), t);
} }
private: private:

39
Src/IACore/inc/hpp/IACore/Logger.hpp
View File

@ -18,30 +18,57 @@
#include <IACore/String.hpp> #include <IACore/String.hpp>
#ifdef __ANDROID__
#include <android/log.h>
#endif
namespace ia namespace ia
{ {
class Logger class Logger
{ {
public: public:
template<typename... Args> STATIC VOID Info(Args... args) template<typename... Args> STATIC VOID Info(PCCHAR tag, Args... args)
{ {
StringStream ss; StringStream ss;
UNUSED((ss << ... << args)); UNUSED((ss << ... << args));
printf("\033[32m[INFO]: %s\033[39m\n", ss.str().c_str()); #ifdef __ANDROID__
__android_log_print(ANDROID_LOG_DEBUG, "IAApp", ss.str().c_str());
#else
printf("\033[0;37m[INFO]: [%s] %s\033[39m\n", tag, ss.str().c_str());
#endif
} }
template<typename... Args> STATIC VOID Warn(Args... args) template<typename... Args> STATIC VOID Success(PCCHAR tag, Args... args)
{ {
StringStream ss; StringStream ss;
UNUSED((ss << ... << args)); UNUSED((ss << ... << args));
printf("\033[33m[WARN]: %s\033[39m\n", ss.str().c_str()); #ifdef __ANDROID__
__android_log_print(ANDROID_LOG_INFO, "IAApp", ss.str().c_str());
#else
printf("\033[32m[SUCCESS]: [%s] %s\033[39m\n", tag, ss.str().c_str());
#endif
} }
template<typename... Args> STATIC VOID Error(Args... args) template<typename... Args> STATIC VOID Warn(PCCHAR tag, Args... args)
{ {
StringStream ss; StringStream ss;
UNUSED((ss << ... << args)); UNUSED((ss << ... << args));
printf("\033[31m[ERROR]: %s\033[39m\n", ss.str().c_str()); #ifdef __ANDROID__
__android_log_print(ANDROID_LOG_DEBUG, "IAApp", ss.str().c_str());
#else
printf("\033[33m[WARN]: [%s] %s\033[39m\n", tag, ss.str().c_str());
#endif
}
template<typename... Args> STATIC VOID Error(PCCHAR tag, Args... args)
{
StringStream ss;
UNUSED((ss << ... << args));
#ifdef __ANDROID__
__android_log_print(ANDROID_LOG_ERROR, "IAApp", ss.str().c_str());
#else
printf("\033[31m[ERROR]: [%s] %s\033[39m\n", tag, ss.str().c_str());
#endif
} }
private: private:

2
Src/IACoreTest/CMakeLists.txt
View File

@ -1,8 +1,6 @@
add_executable(IACoreTest imp/cpp/Main.cpp) add_executable(IACoreTest imp/cpp/Main.cpp)
target_compile_options(IACoreTest PRIVATE target_compile_options(IACoreTest PRIVATE
"-g"
"-O0"
"-D__IA_DEBUG=1" "-D__IA_DEBUG=1"
) )

2
Src/IACoreTest/imp/cpp/Main.cpp
View File

@ -10,7 +10,7 @@ template<typename _value_type>
VOID print(IN CONST Span<_value_type>& s) VOID print(IN CONST Span<_value_type>& s)
{ {
for(const auto& v: s) for(const auto& v: s)
Logger::Info(v); Logger::Info("IACore", v);
} }
int main(int argc, char* argv[]) int main(int argc, char* argv[])