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

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

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

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

@ -47,7 +47,7 @@ namespace ia
UNUSED(hint);
const size_type size = (sizeof(value_type) * count);
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;
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; }
VOID clear()
{
m_impl.clear();
}
private:
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;
res.reserve((count/stride) + 2);
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';
return IA_MOVE(res);
}

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

@ -27,12 +27,6 @@
#include <type_traits>
#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 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_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_RED "\033[31m"
#define __CC_GREEN "\033[32m"

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

@ -16,7 +16,7 @@
#pragma once
#include <IACore/String.hpp>
#include <IACore/Logger.hpp>
namespace ia {
enum class ExceptionKind {
@ -131,7 +131,9 @@ private:
DO(SECURITY_BYPASS)
#define DEFINE_THROWER(name) \
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);
#undef DEFINE_THROWER

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

@ -121,10 +121,10 @@ namespace ia
if constexpr (includeExtension)
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 = '/';
@ -132,7 +132,10 @@ namespace ia
if (t == path.end())
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:

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

@ -18,30 +18,57 @@
#include <IACore/String.hpp>
#ifdef __ANDROID__
#include <android/log.h>
#endif
namespace ia
{
class Logger
{
public:
template<typename... Args> STATIC VOID Info(Args... args)
template<typename... Args> STATIC VOID Info(PCCHAR tag, Args... args)
{
StringStream ss;
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;
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;
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:

2
Src/IACoreTest/CMakeLists.txt
View File

@ -1,8 +1,6 @@
add_executable(IACoreTest imp/cpp/Main.cpp)
target_compile_options(IACoreTest PRIVATE
"-g"
"-O0"
"-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)
{
for(const auto& v: s)
Logger::Info(v);
Logger::Info("IACore", v);
}
int main(int argc, char* argv[])