IDataBlob: added Offset parameter to GetDataPtr and GetConstDataPtr methods

TheMostDiligent · TheMostDiligent · commit 3293ab2f0e4d · 2024-10-28T14:32:14.000-07:00
diff --git a/Common/interface/DataBlobImpl.hpp b/Common/interface/DataBlobImpl.hpp
@@ -60,21 +60,21 @@ class DataBlobImpl final : public Diligent::ObjectBase<IDataBlob>
     virtual size_t DILIGENT_CALL_TYPE GetSize() const override;
 
     /// Returns the pointer to the internal data buffer
-    virtual void* DILIGENT_CALL_TYPE GetDataPtr() override;
+    virtual void* DILIGENT_CALL_TYPE GetDataPtr(size_t Offset = 0) override;
 
     /// Returns const pointer to the internal data buffer
-    virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr() const override;
+    virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr(size_t Offset = 0) const override;
 
     template <typename T>
-    T* GetDataPtr()
+    T* GetDataPtr(size_t Offset = 0)
     {
-        return reinterpret_cast<T*>(GetDataPtr());
+        return reinterpret_cast<T*>(GetDataPtr(Offset));
     }
 
     template <typename T>
-    const T* GetConstDataPtr() const
+    const T* GetConstDataPtr(size_t Offset = 0) const
     {
-        return reinterpret_cast<const T*>(GetConstDataPtr());
+        return reinterpret_cast<const T*>(GetConstDataPtr(Offset));
     }
 
 private:
diff --git a/Common/interface/ProxyDataBlob.hpp b/Common/interface/ProxyDataBlob.hpp
@@ -78,15 +78,17 @@ class ProxyDataBlob : public ObjectBase<IDataBlob>
     }
 
     /// Returns the pointer to the internal data buffer
-    virtual void* DILIGENT_CALL_TYPE GetDataPtr() override
+    virtual void* DILIGENT_CALL_TYPE GetDataPtr(size_t Offset = 0) override
     {
-        return m_pData;
+        VERIFY(Offset < m_Size, "Offset (", Offset, ") exceeds the data size (", m_Size, ")");
+        return static_cast<Uint8*>(m_pData) + Offset;
     }
 
     /// Returns the pointer to the internal data buffer
-    virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr() const override
+    virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr(size_t Offset = 0) const override
     {
-        return m_pConstData;
+        VERIFY(Offset < m_Size, "Offset (", Offset, ") exceeds the data size (", m_Size, ")");
+        return static_cast<const Uint8*>(m_pConstData) + Offset;
     }
 
 private:
diff --git a/Common/interface/StringDataBlobImpl.hpp b/Common/interface/StringDataBlobImpl.hpp
@@ -73,15 +73,15 @@ class StringDataBlobImpl : public ObjectBase<IDataBlob>
     }
 
     /// Returns the pointer to the internal data buffer
-    virtual void* DILIGENT_CALL_TYPE GetDataPtr() override
+    virtual void* DILIGENT_CALL_TYPE GetDataPtr(size_t Offset = 0) override
     {
-        return &m_String[0];
+        return &m_String[Offset];
     }
 
     /// Returns the pointer to the internal data buffer
-    virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr() const override
+    virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr(size_t Offset = 0) const override
     {
-        return &m_String[0];
+        return &m_String[Offset];
     }
 
 private:
diff --git a/Common/src/DataBlobImpl.cpp b/Common/src/DataBlobImpl.cpp
@@ -72,15 +72,15 @@ size_t DataBlobImpl::GetSize() const
 }
 
 /// Returns the pointer to the internal data buffer
-void* DataBlobImpl::GetDataPtr()
+void* DataBlobImpl::GetDataPtr(size_t Offset)
 {
-    return m_DataBuff.data();
+    return &m_DataBuff[Offset];
 }
 
 /// Returns const pointer to the internal data buffer
-const void* DataBlobImpl::GetConstDataPtr() const
+const void* DataBlobImpl::GetConstDataPtr(size_t Offset) const
 {
-    return m_DataBuff.data();
+    return &m_DataBuff[Offset];
 }
 
 IMPLEMENT_QUERY_INTERFACE(DataBlobImpl, IID_DataBlob, TBase)
diff --git a/Common/src/MemoryFileStream.cpp b/Common/src/MemoryFileStream.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -50,19 +50,19 @@ IMPLEMENT_QUERY_INTERFACE(MemoryFileStream, IID_FileStream, TBase)
 bool MemoryFileStream::Read(void* Data, size_t Size)
 {
     VERIFY_EXPR(m_CurrentOffset <= m_DataBlob->GetSize());
-    auto  BytesLeft   = m_DataBlob->GetSize() - m_CurrentOffset;
-    auto  BytesToRead = std::min(BytesLeft, Size);
-    auto* pSrcData    = reinterpret_cast<const Uint8*>(m_DataBlob->GetDataPtr()) + m_CurrentOffset;
+    size_t      BytesLeft   = m_DataBlob->GetSize() - m_CurrentOffset;
+    size_t      BytesToRead = std::min(BytesLeft, Size);
+    const void* pSrcData    = m_DataBlob->GetConstDataPtr(m_CurrentOffset);
     memcpy(Data, pSrcData, BytesToRead);
     m_CurrentOffset += BytesToRead;
     return Size == BytesToRead;
 }
 
 void MemoryFileStream::ReadBlob(IDataBlob* pData)
 {
-    auto BytesLeft = m_DataBlob->GetSize() - m_CurrentOffset;
+    size_t BytesLeft = m_DataBlob->GetSize() - m_CurrentOffset;
     pData->Resize(BytesLeft);
-    auto res = Read(pData->GetDataPtr(), pData->GetSize());
+    bool res = Read(pData->GetDataPtr(), pData->GetSize());
     VERIFY_EXPR(res);
     (void)res;
 }
@@ -73,7 +73,7 @@ bool MemoryFileStream::Write(const void* Data, size_t Size)
     {
         m_DataBlob->Resize(m_CurrentOffset + Size);
     }
-    auto* DstData = reinterpret_cast<Uint8*>(m_DataBlob->GetDataPtr()) + m_CurrentOffset;
+    void* DstData = m_DataBlob->GetDataPtr(m_CurrentOffset);
     memcpy(DstData, Data, Size);
     m_CurrentOffset += Size;
     return true;
diff --git a/Primitives/interface/DataBlob.h b/Primitives/interface/DataBlob.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -59,10 +59,12 @@ DILIGENT_BEGIN_INTERFACE(IDataBlob, IObject)
     VIRTUAL size_t METHOD(GetSize)(THIS) CONST PURE;
 
     /// Returns the pointer to the internal data buffer
-    VIRTUAL void* METHOD(GetDataPtr)(THIS) PURE;
+    VIRTUAL void* METHOD(GetDataPtr)(THIS_
+                                     size_t Offset DEFAULT_VALUE(0)) PURE;
 
     /// Returns const pointer to the internal data buffer
-    VIRTUAL const void* METHOD(GetConstDataPtr)(THIS) CONST PURE;
+    VIRTUAL const void* METHOD(GetConstDataPtr)(THIS_
+                                                size_t Offset DEFAULT_VALUE(0)) CONST PURE;
 };
 DILIGENT_END_INTERFACE
 
@@ -72,10 +74,10 @@ DILIGENT_END_INTERFACE
 
 // clang-format off
 
-#    define IDataBlob_Resize(This, ...)      CALL_IFACE_METHOD(DataBlob, Resize,          This, __VA_ARGS__)
-#    define IDataBlob_GetSize(This)          CALL_IFACE_METHOD(DataBlob, GetSize,         This)
-#    define IDataBlob_GetDataPtr(This)       CALL_IFACE_METHOD(DataBlob, GetDataPtr,      This)
-#    define IDataBlob_GetConstDataPtr(This)  CALL_IFACE_METHOD(DataBlob, GetConstDataPtr, This)
+#    define IDataBlob_Resize(This, ...)           CALL_IFACE_METHOD(DataBlob, Resize,          This, __VA_ARGS__)
+#    define IDataBlob_GetSize(This)               CALL_IFACE_METHOD(DataBlob, GetSize,         This)
+#    define IDataBlob_GetDataPtr(This, ...)       CALL_IFACE_METHOD(DataBlob, GetDataPtr,      This, __VA_ARGS__)
+#    define IDataBlob_GetConstDataPtr(This, ...)  CALL_IFACE_METHOD(DataBlob, GetConstDataPtr, This, __VA_ARGS__)
 
 // clang-format on
 

Original file line number	Diff line number	Diff line change
`@@ -60,21 +60,21 @@ class DataBlobImpl final : public Diligent::ObjectBase<IDataBlob>`
`60`	`60`	`virtual size_t DILIGENT_CALL_TYPE GetSize() const override;`
`61`	`61`
`62`	`62`	`/// Returns the pointer to the internal data buffer`
`63`		`- virtual void* DILIGENT_CALL_TYPE GetDataPtr() override;`
	`63`	`+ virtual void* DILIGENT_CALL_TYPE GetDataPtr(size_t Offset = 0) override;`
`64`	`64`
`65`	`65`	`/// Returns const pointer to the internal data buffer`
`66`		`- virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr() const override;`
	`66`	`+ virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr(size_t Offset = 0) const override;`
`67`	`67`
`68`	`68`	`template <typename T>`
`69`		`- T* GetDataPtr()`
	`69`	`+ T* GetDataPtr(size_t Offset = 0)`
`70`	`70`	`{`
`71`		`- return reinterpret_cast<T*>(GetDataPtr());`
	`71`	`+ return reinterpret_cast<T*>(GetDataPtr(Offset));`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`template <typename T>`
`75`		`- const T* GetConstDataPtr() const`
	`75`	`+ const T* GetConstDataPtr(size_t Offset = 0) const`
`76`	`76`	`{`
`77`		`- return reinterpret_cast<const T*>(GetConstDataPtr());`
	`77`	`+ return reinterpret_cast<const T*>(GetConstDataPtr(Offset));`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -78,15 +78,17 @@ class ProxyDataBlob : public ObjectBase<IDataBlob>`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`/// Returns the pointer to the internal data buffer`
`81`		`- virtual void* DILIGENT_CALL_TYPE GetDataPtr() override`
	`81`	`+ virtual void* DILIGENT_CALL_TYPE GetDataPtr(size_t Offset = 0) override`
`82`	`82`	`{`
`83`		`- return m_pData;`
	`83`	`+ VERIFY(Offset < m_Size, "Offset (", Offset, ") exceeds the data size (", m_Size, ")");`
	`84`	`+ return static_cast<Uint8*>(m_pData) + Offset;`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`/// Returns the pointer to the internal data buffer`
`87`		`- virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr() const override`
	`88`	`+ virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr(size_t Offset = 0) const override`
`88`	`89`	`{`
`89`		`- return m_pConstData;`
	`90`	`+ VERIFY(Offset < m_Size, "Offset (", Offset, ") exceeds the data size (", m_Size, ")");`
	`91`	`+ return static_cast<const Uint8*>(m_pConstData) + Offset;`
`90`	`92`	`}`
`91`	`93`
`92`	`94`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -73,15 +73,15 @@ class StringDataBlobImpl : public ObjectBase<IDataBlob>`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`/// Returns the pointer to the internal data buffer`
`76`		`- virtual void* DILIGENT_CALL_TYPE GetDataPtr() override`
	`76`	`+ virtual void* DILIGENT_CALL_TYPE GetDataPtr(size_t Offset = 0) override`
`77`	`77`	`{`
`78`		`- return &m_String[0];`
	`78`	`+ return &m_String[Offset];`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`/// Returns the pointer to the internal data buffer`
`82`		`- virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr() const override`
	`82`	`+ virtual const void* DILIGENT_CALL_TYPE GetConstDataPtr(size_t Offset = 0) const override`
`83`	`83`	`{`
`84`		`- return &m_String[0];`
	`84`	`+ return &m_String[Offset];`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -72,15 +72,15 @@ size_t DataBlobImpl::GetSize() const`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`/// Returns the pointer to the internal data buffer`
`75`		`-void* DataBlobImpl::GetDataPtr()`
	`75`	`+void* DataBlobImpl::GetDataPtr(size_t Offset)`
`76`	`76`	`{`
`77`		`- return m_DataBuff.data();`
	`77`	`+ return &m_DataBuff[Offset];`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`/// Returns const pointer to the internal data buffer`
`81`		`-const void* DataBlobImpl::GetConstDataPtr() const`
	`81`	`+const void* DataBlobImpl::GetConstDataPtr(size_t Offset) const`
`82`	`82`	`{`
`83`		`- return m_DataBuff.data();`
	`83`	`+ return &m_DataBuff[Offset];`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`IMPLEMENT_QUERY_INTERFACE(DataBlobImpl, IID_DataBlob, TBase)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2019-2022 Diligent Graphics LLC`
	`2`	`+ * Copyright 2019-2024 Diligent Graphics LLC`
`3`	`3`	`* Copyright 2015-2019 Egor Yusov`
`4`	`4`	`*`
`5`	`5`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`@@ -50,19 +50,19 @@ IMPLEMENT_QUERY_INTERFACE(MemoryFileStream, IID_FileStream, TBase)`
`50`	`50`	`bool MemoryFileStream::Read(void* Data, size_t Size)`
`51`	`51`	`{`
`52`	`52`	`VERIFY_EXPR(m_CurrentOffset <= m_DataBlob->GetSize());`
`53`		`- auto BytesLeft = m_DataBlob->GetSize() - m_CurrentOffset;`
`54`		`- auto BytesToRead = std::min(BytesLeft, Size);`
`55`		`- auto* pSrcData = reinterpret_cast<const Uint8*>(m_DataBlob->GetDataPtr()) + m_CurrentOffset;`
	`53`	`+ size_t BytesLeft = m_DataBlob->GetSize() - m_CurrentOffset;`
	`54`	`+ size_t BytesToRead = std::min(BytesLeft, Size);`
	`55`	`+ const void* pSrcData = m_DataBlob->GetConstDataPtr(m_CurrentOffset);`
`56`	`56`	`memcpy(Data, pSrcData, BytesToRead);`
`57`	`57`	`m_CurrentOffset += BytesToRead;`
`58`	`58`	`return Size == BytesToRead;`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`void MemoryFileStream::ReadBlob(IDataBlob* pData)`
`62`	`62`	`{`
`63`		`- auto BytesLeft = m_DataBlob->GetSize() - m_CurrentOffset;`
	`63`	`+ size_t BytesLeft = m_DataBlob->GetSize() - m_CurrentOffset;`
`64`	`64`	`pData->Resize(BytesLeft);`
`65`		`- auto res = Read(pData->GetDataPtr(), pData->GetSize());`
	`65`	`+ bool res = Read(pData->GetDataPtr(), pData->GetSize());`
`66`	`66`	`VERIFY_EXPR(res);`
`67`	`67`	`(void)res;`
`68`	`68`	`}`
`@@ -73,7 +73,7 @@ bool MemoryFileStream::Write(const void* Data, size_t Size)`
`73`	`73`	`{`
`74`	`74`	`m_DataBlob->Resize(m_CurrentOffset + Size);`
`75`	`75`	`}`
`76`		`- auto* DstData = reinterpret_cast<Uint8*>(m_DataBlob->GetDataPtr()) + m_CurrentOffset;`
	`76`	`+ void* DstData = m_DataBlob->GetDataPtr(m_CurrentOffset);`
`77`	`77`	`memcpy(DstData, Data, Size);`
`78`	`78`	`m_CurrentOffset += Size;`
`79`	`79`	`return true;`