Menu
▾
▴
[OMPT-svn-commit] SF.net SVN: modplug:[4285] trunk/OpenMPT
|
From: <man...@us...> - 2014-09-12 11:26:41
|
Revision: 4285
http://sourceforge.net/p/modplug/code/4285
Author: manxorist
Date: 2014-09-12 11:26:26 +0000 (Fri, 12 Sep 2014)
Log Message:
-----------
[Ref] serialization_utils: In order to improve code readability, replace open-coded (const char*, size) tuples for Id fields with a class ID which is just a small wrapper around std::string. As IDs are really short (most of the time 4 bytes), std::string usage is fine as small-string-optimization avoids further allocations.
Modified Paths:
--------------
trunk/OpenMPT/common/serialization_utils.cpp
trunk/OpenMPT/common/serialization_utils.h
trunk/OpenMPT/soundlib/Load_it.cpp
trunk/OpenMPT/soundlib/ModSequence.cpp
trunk/OpenMPT/soundlib/pattern.cpp
trunk/OpenMPT/soundlib/patternContainer.cpp
trunk/OpenMPT/soundlib/tuning.cpp
trunk/OpenMPT/soundlib/tuningCollection.cpp
Modified: trunk/OpenMPT/common/serialization_utils.cpp
===================================================================
--- trunk/OpenMPT/common/serialization_utils.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/common/serialization_utils.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -39,17 +39,20 @@
}
-static bool IsPrintableId(const char* pId, const size_t nLength)
-//--------------------------------------------------------------
+bool ID::IsPrintable() const
+//--------------------------
{
- for(size_t i = 0; i < nLength; i++)
+ for(std::size_t i = 0; i < m_ID.length(); ++i)
{
- if (pId[i] <= 0 || isprint(pId[i]) == 0)
+ if(m_ID[i] <= 0 || isprint(m_ID[i]) == 0)
+ {
return false;
+ }
}
return true;
}
+
//Format: First bit tells whether the size indicator is 1 or 2 bytes.
static void WriteAdaptive12String(std::ostream& oStrm, const std::string& str)
//----------------------------------------------------------------------------
@@ -104,25 +107,30 @@
}
-static std::string IdToString(const char* const pvId, const size_t nLength)
-//-------------------------------------------------------------------------
+std::string ID::AsString() const
+//------------------------------
{
- const char* pId = static_cast<const char*>(pvId);
- if (nLength == 0)
- return "";
- std::string str;
- if (IsPrintableId(pId, nLength))
- std::copy(pId, pId + nLength, std::back_inserter<std::string>(str));
- else if (nLength <= 8) // Interpret ID as integer value.
+ if(IsPrintable())
{
- int64 val = 0;
- std::memcpy(&val, pId, nLength);
- val = SwapBytesReturnLE(val);
- str = Stringify(val);
+ return m_ID;
}
- return str;
+ if(m_ID.length() > 8)
+ {
+ return std::string();
+ }
+ uint64 val = 0;
+ uint8 bytes[8];
+ std::memset(bytes, 0, 8);
+ for(std::size_t i = 0; i < m_ID.length(); ++i)
+ {
+ bytes[i] = m_ID[i];
+ }
+ std::memcpy(&val, bytes, m_ID.length());
+ val = SwapBytesReturnLE(val);
+ return mpt::ToString(val);
}
+
const char Ssb::s_EntryID[3] = {'2','2','8'};
const char tstrWriteHeader[] = "Write header with ID = %s\n";
@@ -214,7 +222,7 @@
m_fpLogFunc(
tstrReadProgress,
nNum,
- (pRe && pRe->nIdLength < 30 && m_Idarray.size() > 0) ? IdToString(&m_Idarray[pRe->nIdpos], pRe->nIdLength).c_str() : "",
+ (pRe && pRe->nIdLength < 30 && m_Idarray.size() > 0) ? ID(&m_Idarray[pRe->nIdpos], pRe->nIdLength).AsString().c_str() : "",
(pRe) ? pRe->rposStart : 0,
(pRe && pRe->nSize != invalidDatasize) ? Stringify(pRe->nSize).c_str() : "",
"");
@@ -223,14 +231,14 @@
// Called after writing an entry.
-void SsbWrite::AddWriteNote(const char* pId, const size_t nIdSize, const NumType nEntryNum, const DataSize nBytecount, const RposType rposStart)
-//----------------------------------------------------------------------------
+void SsbWrite::AddWriteNote(const ID &id, const NumType nEntryNum, const DataSize nBytecount, const RposType rposStart)
+//---------------------------------------------------------------------------------------------------------------------
{
m_Status |= SNT_PROGRESS;
if (m_fpLogFunc)
{
{
- m_fpLogFunc(tstrWriteProgress, nEntryNum, IdToString(pId, nIdSize).c_str(), rposStart, nBytecount);
+ m_fpLogFunc(tstrWriteProgress, nEntryNum, id.AsString().c_str(), rposStart, nBytecount);
}
}
}
@@ -245,16 +253,15 @@
}
-void SsbWrite::WriteMapItem( const char* pId,
- const size_t nIdSize,
+void SsbWrite::WriteMapItem(const ID &id,
const RposType& rposDataStart,
const DataSize& nDatasize,
const char* pszDesc)
-//----------------------------------------------
+//----------------------------------------
{
if (m_fpLogFunc)
m_fpLogFunc(tstrMapEntryWrite,
- (nIdSize > 0) ? IdToString(pId, nIdSize).c_str() : "",
+ (id.GetSize() > 0) ? id.AsString().c_str() : "",
rposDataStart,
nDatasize);
@@ -262,14 +269,14 @@
if(m_nIdbytes > 0)
{
- if (m_nIdbytes != IdSizeVariable && nIdSize != m_nIdbytes)
+ if (m_nIdbytes != IdSizeVariable && id.GetSize() != m_nIdbytes)
{ AddWriteNote(SNW_CHANGING_IDSIZE_WITH_FIXED_IDSIZESETTING); return; }
if (m_nIdbytes == IdSizeVariable) //Variablesize ID?
- mpt::IO::WriteAdaptiveInt16LE(mapStream, static_cast<uint16>(nIdSize));
+ mpt::IO::WriteAdaptiveInt16LE(mapStream, static_cast<uint16>(id.GetSize()));
- if(nIdSize > 0)
- mapStream.write(pId, nIdSize);
+ if(id.GetSize() > 0)
+ mapStream.write(id.GetBytes(), id.GetSize());
}
if (GetFlag(RwfWMapStartPosEntry)) //Startpos
@@ -296,13 +303,13 @@
}
-void SsbWrite::BeginWrite(const char* pId, const size_t nIdSize, const uint64& nVersion)
-//---------------------------------------------------------------------------------
+void SsbWrite::BeginWrite(const ID &id, const uint64& nVersion)
+//-------------------------------------------------------------
{
std::ostream& oStrm = *m_pOstrm;
if (m_fpLogFunc)
- m_fpLogFunc(tstrWriteHeader, IdToString(pId, nIdSize).c_str());
+ m_fpLogFunc(tstrWriteHeader, id.AsString().c_str());
ResetWritestatus();
@@ -316,9 +323,9 @@
// Object ID.
{
- uint8 idsize = static_cast<uint8>(nIdSize);
+ uint8 idsize = static_cast<uint8>(id.GetSize());
Binarywrite<uint8>(oStrm, idsize);
- if(idsize > 0) oStrm.write(pId, nIdSize);
+ if(idsize > 0) oStrm.write(id.GetBytes(), id.GetSize());
}
// Form header.
@@ -375,8 +382,8 @@
}
-SsbRead::ReadRv SsbRead::OnReadEntry(const ReadEntry* pE, const char* pId, const size_t nIdSize, const Postype& posReadBegin)
-//-------------------------------------------------------------------------------------------------------------------
+SsbRead::ReadRv SsbRead::OnReadEntry(const ReadEntry* pE, const ID &id, const Postype& posReadBegin)
+//--------------------------------------------------------------------------------------------------
{
if (pE != nullptr)
AddReadNote(pE, m_nCounter);
@@ -390,7 +397,7 @@
else // Entry not found.
{
if (m_fpLogFunc)
- m_fpLogFunc(tstrNoEntryFound, IdToString(pId, nIdSize).c_str());
+ m_fpLogFunc(tstrNoEntryFound, id.AsString().c_str());
return EntryNotFound;
}
m_nCounter++;
@@ -398,8 +405,8 @@
}
-void SsbWrite::OnWroteItem(const char* pId, const size_t nIdSize, const Postype& posBeforeWrite)
-//-----------------------------------------------------------------------------------------
+void SsbWrite::OnWroteItem(const ID &id, const Postype& posBeforeWrite)
+//---------------------------------------------------------------------
{
const Offtype nRawEntrySize = m_pOstrm->tellp() - posBeforeWrite;
@@ -424,37 +431,21 @@
{ AddWriteNote(SNW_INSUFFICIENT_FIXEDSIZE); return; }
}
if (GetFlag(RwfRwHasMap))
- WriteMapItem(pId, nIdSize, static_cast<RposType>(posBeforeWrite - m_posStart), nEntrySize, "");
+ WriteMapItem(id, static_cast<RposType>(posBeforeWrite - m_posStart), nEntrySize, "");
if (m_fpLogFunc != nullptr)
- AddWriteNote(pId, nIdSize, m_nCounter, nEntrySize, static_cast<RposType>(posBeforeWrite - m_posStart));
+ AddWriteNote(id, m_nCounter, nEntrySize, static_cast<RposType>(posBeforeWrite - m_posStart));
IncrementWriteCounter();
}
-void SsbRead::CompareId(std::istream& iStrm, const char* pId, const size_t nIdlength)
-//---------------------------------------------------------------------------
+void SsbRead::BeginRead(const ID &id, const uint64& nVersion)
+//-----------------------------------------------------------
{
- uint8 tempU8 = 0;
- Binaryread<uint8>(iStrm, tempU8);
- char buffer[256];
- if(tempU8)
- iStrm.read(buffer, tempU8);
-
- if (tempU8 == nIdlength && nIdlength > 0 && memcmp(buffer, pId, nIdlength) == 0)
- return; // Match.
-
- AddReadNote(SNR_OBJECTCLASS_IDMISMATCH);
-}
-
-
-void SsbRead::BeginRead(const char* pId, const size_t nLength, const uint64& nVersion)
-//---------------------------------------------------------------------------------
-{
std::istream& iStrm = *m_pIstrm;
if (m_fpLogFunc)
- m_fpLogFunc(tstrReadingHeader, IdToString(pId, nLength).c_str());
+ m_fpLogFunc(tstrReadingHeader, id.AsString().c_str());
ResetReadstatus();
@@ -467,7 +458,7 @@
{
char temp[sizeof(s_EntryID)];
ArrayReader<char>(sizeof(s_EntryID))(iStrm, temp, sizeof(s_EntryID));
- if (memcmp(temp, s_EntryID, sizeof(s_EntryID)))
+ if(std::memcmp(temp, s_EntryID, sizeof(s_EntryID)))
{
AddReadNote(SNR_STARTBYTE_MISMATCH);
return;
@@ -475,7 +466,18 @@
}
// Compare IDs.
- CompareId(iStrm, pId, nLength);
+ uint8 storedIdLen = 0;
+ Binaryread<uint8>(iStrm, storedIdLen);
+ char storedIdBuf[256];
+ MemsetZero(storedIdBuf);
+ if(storedIdLen > 0)
+ {
+ iStrm.read(storedIdBuf, storedIdLen);
+ }
+ if(!(id == ID(storedIdBuf, storedIdLen)))
+ {
+ AddReadNote(SNR_OBJECTCLASS_IDMISMATCH);
+ }
if ((m_Status & SNT_FAILURE) != 0)
{
if (m_fpLogFunc)
@@ -689,8 +691,8 @@
}
-const ReadEntry* SsbRead::Find(const char* pId, const size_t nIdLength)
-//-----------------------------------------------------------------
+const ReadEntry* SsbRead::Find(const ID &id)
+//------------------------------------------
{
m_pIstrm->clear();
if (GetFlag(RwfRMapCached) == false)
@@ -705,8 +707,7 @@
for(size_t i0 = 0; i0 < nEntries; i0++)
{
const size_t i = (i0 + m_nNextReadHint) % nEntries;
- if (mapData[i].nIdLength == nIdLength && mapData[i].nIdpos < m_Idarray.size() &&
- memcmp(&m_Idarray[mapData[i].nIdpos], pId, mapData[i].nIdLength) == 0)
+ if(mapData[i].nIdpos < m_Idarray.size() && id == ID(&m_Idarray[mapData[i].nIdpos], mapData[i].nIdLength))
{
m_nNextReadHint = (i + 1) % nEntries;
if (mapData[i].rposStart != 0)
Modified: trunk/OpenMPT/common/serialization_utils.h
===================================================================
--- trunk/OpenMPT/common/serialization_utils.h 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/common/serialization_utils.h 2014-09-12 11:26:26 UTC (rev 4285)
@@ -197,6 +197,37 @@
+class ID
+{
+private:
+ std::string m_ID; // NOTE: can contain null characters ('\0')
+public:
+ ID() { }
+ ID(const std::string &id) : m_ID(id) { }
+ ID(const char *beg, const char *end) : m_ID(beg, end) { }
+ ID(const char *id) : m_ID(id?id:"") { }
+ ID(const char * str, std::size_t len) : m_ID(str, str + len) { }
+ template <typename T>
+ static ID FromInt(const T &val)
+ {
+ STATIC_ASSERT(std::numeric_limits<T>::is_integer);
+ char bytes[sizeof(T)];
+ std::memcpy(bytes, &val, sizeof(T));
+ #ifdef MPT_PLATFORM_BIG_ENDIAN
+ std::reverse(bytes, bytes + sizeof(T));
+ #endif
+ return ID(bytes, bytes + sizeof(T));
+ }
+ bool IsPrintable() const;
+ std::string AsString() const;
+ const char *GetBytes() const { return m_ID.c_str(); }
+ std::size_t GetSize() const { return m_ID.length(); }
+ bool operator == (const ID &other) const { return m_ID == other.m_ID; }
+ bool operator != (const ID &other) const { return m_ID != other.m_ID; }
+};
+
+
+
class Ssb
{
@@ -267,8 +298,7 @@
SsbRead(std::istream& iStrm);
// Call this to begin reading: must be called before other read functions.
- void BeginRead(const char* pId, const size_t nLength, const uint64& nVersion);
- void BeginRead(const char* pszId, const uint64& nVersion) {return BeginRead(pszId, std::strlen(pszId), nVersion);}
+ void BeginRead(const ID &id, const uint64& nVersion);
// After calling BeginRead(), this returns number of entries in the file.
NumType GetNumEntries() const {return m_nReadEntrycount;}
@@ -282,43 +312,35 @@
ReadIterator GetReadEnd();
// Compares given id with read entry id
- IdMatchStatus CompareId(const ReadIterator& iter, const char* pszId) {return CompareId(iter, pszId, std::strlen(pszId));}
- IdMatchStatus CompareId(const ReadIterator& iter, const char* pId, const size_t nIdSize);
+ IdMatchStatus CompareId(const ReadIterator& iter, const ID &id);
uint64 GetReadVersion() {return m_nReadVersion;}
// Read item using default read implementation.
template <class T>
- ReadRv ReadItem(T& obj, const char* pszId) {return ReadItem(obj, pszId, std::strlen(pszId), srlztn::ReadItem<T>);}
+ ReadRv ReadItem(T& obj, const ID &id) {return ReadItem(obj, id, srlztn::ReadItem<T>);}
- template <class T>
- ReadRv ReadItem(T& obj, const char* pId, const size_t nIdSize) {return ReadItem(obj, pId, nIdSize, srlztn::ReadItem<T>);}
-
// Read item using given function.
template <class T, class FuncObj>
- ReadRv ReadItem(T& obj, const char* pId, const size_t nIdSize, FuncObj);
+ ReadRv ReadItem(T& obj, const ID &id, FuncObj);
// Read item using read iterator.
template <class T>
- ReadRv ReadItem(const ReadIterator& iter, T& obj) {return ReadItem(iter, obj, srlztn::ReadItem<T>);}
+ ReadRv ReadIterItem(const ReadIterator& iter, T& obj) {return ReadIterItem(iter, obj, srlztn::ReadItem<T>);}
template <class T, class FuncObj>
- ReadRv ReadItem(const ReadIterator& iter, T& obj, FuncObj func);
+ ReadRv ReadIterItem(const ReadIterator& iter, T& obj, FuncObj func);
private:
// Reads map to cache.
void CacheMap();
- // Compares ID in file with expected ID.
- void CompareId(std::istream& iStrm, const char* pId, const size_t nLength);
-
// Searches for entry with given ID. If found, returns pointer to corresponding entry, else
// returns nullptr.
- const ReadEntry* Find(const char* pId, const size_t nLength);
- const ReadEntry* Find(const char* pszId) {return Find(pszId, std::strlen(pszId));}
+ const ReadEntry* Find(const ID &id);
// Called after reading an object.
- ReadRv OnReadEntry(const ReadEntry* pE, const char* pId, const size_t nIdSize, const Postype& posReadBegin);
+ ReadRv OnReadEntry(const ReadEntry* pE, const ID &id, const Postype& posReadBegin);
void AddReadNote(const SsbStatus s);
@@ -356,19 +378,15 @@
SsbWrite(std::ostream& oStrm);
// Write header
- void BeginWrite(const char* pId, const size_t nIdSize, const uint64& nVersion);
- void BeginWrite(const char* pszId, const uint64& nVersion) {BeginWrite(pszId, std::strlen(pszId), nVersion);}
+ void BeginWrite(const ID &id, const uint64& nVersion);
// Write item using default write implementation.
template <class T>
- void WriteItem(const T& obj, const char* pszId) {WriteItem(obj, pszId, std::strlen(pszId), &srlztn::WriteItem<T>);}
+ void WriteItem(const T& obj, const ID &id) {WriteItem(obj, id, &srlztn::WriteItem<T>);}
- template <class T>
- void WriteItem(const T& obj, const char* pId, const size_t nIdSize) {WriteItem(obj, pId, nIdSize, &srlztn::WriteItem<T>);}
-
// Write item using given function.
template <class T, class FuncObj>
- void WriteItem(const T& obj, const char* pId, const size_t nIdSize, FuncObj);
+ void WriteItem(const T& obj, const ID &id, FuncObj);
// Writes mapping.
void FinishWrite();
@@ -376,18 +394,16 @@
private:
// Called after writing an item.
- void OnWroteItem(const char* pId, const size_t nIdSize, const Postype& posBeforeWrite);
+ void OnWroteItem(const ID &id, const Postype& posBeforeWrite);
void AddWriteNote(const SsbStatus s);
- void AddWriteNote(const char* pId,
- const size_t nIdLength,
+ void AddWriteNote(const ID &id,
const NumType nEntryNum,
const DataSize nBytecount,
const RposType rposStart);
// Writes mapping item to mapstream.
- void WriteMapItem(const char* pId,
- const size_t nIdSize,
+ void WriteMapItem(const ID &id,
const RposType& rposDataStart,
const DataSize& nDatasize,
const char* pszDesc);
@@ -407,66 +423,44 @@
};
-
-template<typename T>
-struct IdLE
-{
- char b[sizeof(T)];
- IdLE(T val)
- {
- std::memcpy(b, &val, sizeof(T));
- #ifdef MPT_PLATFORM_BIG_ENDIAN
- std::reverse(b, b+sizeof(T));
- #endif
- }
- const char* GetChars() const
- {
- return b;
- }
-};
-
-
template <class T, class FuncObj>
-void SsbWrite::WriteItem(const T& obj, const char* pId, const size_t nIdSize, FuncObj Func)
-//------------------------------------------------------------------------------------
+void SsbWrite::WriteItem(const T& obj, const ID &id, FuncObj Func)
+//----------------------------------------------------------------
{
const Postype pos = m_pOstrm->tellp();
Func(*m_pOstrm, obj);
- OnWroteItem(pId, nIdSize, pos);
+ OnWroteItem(id, pos);
}
template <class T, class FuncObj>
-SsbRead::ReadRv SsbRead::ReadItem(T& obj, const char* pId, const size_t nIdSize, FuncObj Func)
-//------------------------------------------------------------------------------------
+SsbRead::ReadRv SsbRead::ReadItem(T& obj, const ID &id, FuncObj Func)
+//-------------------------------------------------------------------
{
- const ReadEntry* pE = Find(pId, nIdSize);
+ const ReadEntry* pE = Find(id);
const Postype pos = m_pIstrm->tellg();
if (pE != nullptr || GetFlag(RwfRMapHasId) == false)
Func(*m_pIstrm, obj, (pE) ? (pE->nSize) : invalidDatasize);
- return OnReadEntry(pE, pId, nIdSize, pos);
+ return OnReadEntry(pE, id, pos);
}
template <class T, class FuncObj>
-SsbRead::ReadRv SsbRead::ReadItem(const ReadIterator& iter, T& obj, FuncObj func)
-//-----------------------------------------------------------------------
+SsbRead::ReadRv SsbRead::ReadIterItem(const ReadIterator& iter, T& obj, FuncObj func)
+//-----------------------------------------------------------------------------------
{
m_pIstrm->clear();
if (iter->rposStart != 0)
m_pIstrm->seekg(m_posStart + Postype(iter->rposStart));
const Postype pos = m_pIstrm->tellg();
func(*m_pIstrm, obj, iter->nSize);
- return OnReadEntry(&(*iter), &m_Idarray[iter->nIdpos], iter->nIdLength, pos);
+ return OnReadEntry(&(*iter), ID(&m_Idarray[iter->nIdpos], iter->nIdLength), pos);
}
-inline SsbRead::IdMatchStatus SsbRead::CompareId(const ReadIterator& iter, const char* pId, const size_t nIdSize)
-//-------------------------------------------------------------------------------------------------------
+inline SsbRead::IdMatchStatus SsbRead::CompareId(const ReadIterator& iter, const ID &id)
+//--------------------------------------------------------------------------------------
{
- if (nIdSize == iter->nIdLength && memcmp(&m_Idarray[iter->nIdpos], pId, iter->nIdLength) == 0)
- return IdMatch;
- else
- return IdMismatch;
+ return (id == ID(&m_Idarray[iter->nIdpos], iter->nIdLength)) ? IdMatch : IdMismatch;
}
Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/soundlib/Load_it.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -1020,11 +1020,11 @@
{
srlztn::SsbRead ssb(iStrm);
ssb.BeginRead("mptm", MptVersion::num);
- ssb.ReadItem(GetTuneSpecificTunings(), "0", 1, &ReadTuningCollection);
- ssb.ReadItem(*this, "1", 1, &ReadTuningMap);
- ssb.ReadItem(Order, "2", 1, &ReadModSequenceOld);
- ssb.ReadItem(Patterns, FileIdPatterns, strlen(FileIdPatterns), &ReadModPatterns);
- ssb.ReadItem(Order, FileIdSequences, strlen(FileIdSequences), &ReadModSequences);
+ ssb.ReadItem(GetTuneSpecificTunings(), "0", &ReadTuningCollection);
+ ssb.ReadItem(*this, "1", &ReadTuningMap);
+ ssb.ReadItem(Order, "2", &ReadModSequenceOld);
+ ssb.ReadItem(Patterns, FileIdPatterns, &ReadModPatterns);
+ ssb.ReadItem(Order, FileIdSequences, &ReadModSequences);
if(ssb.GetStatus() & srlztn::SNT_FAILURE)
{
@@ -1650,14 +1650,14 @@
ssb.BeginWrite("mptm", MptVersion::num);
if(GetTuneSpecificTunings().GetNumTunings() > 0)
- ssb.WriteItem(GetTuneSpecificTunings(), "0", 1, &WriteTuningCollection);
+ ssb.WriteItem(GetTuneSpecificTunings(), "0", &WriteTuningCollection);
if(AreNonDefaultTuningsUsed(*this))
- ssb.WriteItem(*this, "1", 1, &WriteTuningMap);
+ ssb.WriteItem(*this, "1", &WriteTuningMap);
if(Order.NeedsExtraDatafield())
- ssb.WriteItem(Order, "2", 1, &WriteModSequenceOld);
+ ssb.WriteItem(Order, "2", &WriteModSequenceOld);
if(bNeedsMptPatSave)
- ssb.WriteItem(Patterns, FileIdPatterns, strlen(FileIdPatterns), &WriteModPatterns);
- ssb.WriteItem(Order, FileIdSequences, strlen(FileIdSequences), &WriteModSequences);
+ ssb.WriteItem(Patterns, FileIdPatterns, &WriteModPatterns);
+ ssb.WriteItem(Order, FileIdSequences, &WriteModSequences);
ssb.FinishWrite();
Modified: trunk/OpenMPT/soundlib/ModSequence.cpp
===================================================================
--- trunk/OpenMPT/soundlib/ModSequence.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/soundlib/ModSequence.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -819,7 +819,7 @@
ssb.WriteItem(seq.m_sName.c_str(), "n");
const uint16 nLength = seq.GetLengthTailTrimmed();
ssb.WriteItem<uint16>(nLength, "l");
- ssb.WriteItem(seq.m_pArray, "a", 1, srlztn::ArrayWriter<uint16>(nLength));
+ ssb.WriteItem(seq.m_pArray, "a", srlztn::ArrayWriter<uint16>(nLength));
ssb.FinishWrite();
}
@@ -838,7 +838,7 @@
ssb.ReadItem<uint16>(nSize, "l");
LimitMax(nSize, ModSpecs::mptm.ordersMax);
seq.resize(MAX(nSize, ModSequenceSet::s_nCacheSize));
- ssb.ReadItem(seq.m_pArray, "a", 1, srlztn::ArrayReader<uint16>(nSize));
+ ssb.ReadItem(seq.m_pArray, "a", srlztn::ArrayReader<uint16>(nSize));
}
@@ -854,9 +854,9 @@
for(uint8 i = 0; i < nSeqs; i++)
{
if (i == seq.GetCurrentSequenceIndex())
- ssb.WriteItem(seq, srlztn::IdLE<uint8>(i).GetChars(), sizeof(i), &WriteModSequence);
+ ssb.WriteItem(seq, srlztn::ID::FromInt<uint8>(i), &WriteModSequence);
else
- ssb.WriteItem(seq.m_Sequences[i], srlztn::IdLE<uint8>(i).GetChars(), sizeof(i), &WriteModSequence);
+ ssb.WriteItem(seq.m_Sequences[i], srlztn::ID::FromInt<uint8>(i), &WriteModSequence);
}
ssb.FinishWrite();
}
@@ -881,7 +881,7 @@
for(uint8 i = 0; i < nSeqs; i++)
{
- ssb.ReadItem(seq.m_Sequences[i], srlztn::IdLE<uint8>(i).GetChars(), sizeof(i), &ReadModSequence);
+ ssb.ReadItem(seq.m_Sequences[i], srlztn::ID::FromInt<uint8>(i), &ReadModSequence);
}
seq.m_nCurrentSeq = (nCurrent < seq.GetNumSequences()) ? nCurrent : 0;
seq.CopyStorageToCache();
Modified: trunk/OpenMPT/soundlib/pattern.cpp
===================================================================
--- trunk/OpenMPT/soundlib/pattern.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/soundlib/pattern.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -486,7 +486,7 @@
{
srlztn::SsbWrite ssb(oStrm);
ssb.BeginWrite(FileIdPattern, MptVersion::num);
- ssb.WriteItem(pat, "data", strlen("data"), &WriteData);
+ ssb.WriteItem(pat, "data", &WriteData);
// pattern time signature
if(pat.GetOverrideSignature())
{
@@ -504,7 +504,7 @@
ssb.BeginRead(FileIdPattern, MptVersion::num);
if ((ssb.GetStatus() & srlztn::SNT_FAILURE) != 0)
return;
- ssb.ReadItem(pat, "data", strlen("data"), &ReadData);
+ ssb.ReadItem(pat, "data", &ReadData);
// pattern time signature
uint32 nRPB = 0, nRPM = 0;
ssb.ReadItem<uint32>(nRPB, "RPB.");
Modified: trunk/OpenMPT/soundlib/patternContainer.cpp
===================================================================
--- trunk/OpenMPT/soundlib/patternContainer.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/soundlib/patternContainer.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -201,7 +201,7 @@
uint16 nCount = 0;
for(uint16 i = 0; i < nPatterns; i++) if (patc[i])
{
- ssb.WriteItem(patc[i], srlztn::IdLE<uint16>(i).GetChars(), sizeof(i), &WriteModPattern);
+ ssb.WriteItem(patc[i], srlztn::ID::FromInt<uint16>(i), &WriteModPattern);
nCount = i + 1;
}
ssb.WriteItem<uint16>(nCount, "num"); // Index of last pattern + 1.
@@ -225,7 +225,7 @@
patc.ResizeArray(nPatterns);
for(uint16 i = 0; i < nPatterns; i++)
{
- ssb.ReadItem(patc[i], srlztn::IdLE<uint16>(i).GetChars(), sizeof(i), &ReadModPattern);
+ ssb.ReadItem(patc[i], srlztn::ID::FromInt<uint16>(i), &ReadModPattern);
}
}
Modified: trunk/OpenMPT/soundlib/tuning.cpp
===================================================================
--- trunk/OpenMPT/soundlib/tuning.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/soundlib/tuning.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -384,14 +384,14 @@
srlztn::SsbRead ssb(iStrm);
ssb.BeginRead("CTB244RTI", (CTuning::GetVersion() << 24) + GetVersion());
- ssb.ReadItem(pTuning->m_TuningName, "0", 1, ReadStr);
+ ssb.ReadItem(pTuning->m_TuningName, "0", ReadStr);
ssb.ReadItem(pTuning->m_EditMask, "1");
ssb.ReadItem(pTuning->m_TuningType, "2");
- ssb.ReadItem(pTuning->m_NoteNameMap, "3", 1, ReadNoteMap);
+ ssb.ReadItem(pTuning->m_NoteNameMap, "3", ReadNoteMap);
ssb.ReadItem(pTuning->m_FineStepCount, "4");
// RTI entries.
- ssb.ReadItem(pTuning->m_RatioTable, "RTI0", 4, ReadRatioTable);
+ ssb.ReadItem(pTuning->m_RatioTable, "RTI0", ReadRatioTable);
ssb.ReadItem(pTuning->m_StepMin, "RTI1");
ssb.ReadItem(pTuning->m_GroupSize, "RTI2");
ssb.ReadItem(pTuning->m_GroupRatio, "RTI3");
@@ -476,11 +476,11 @@
srlztn::SsbWrite ssb(outStrm);
ssb.BeginWrite("CTB244RTI", (GetVersion() << 24) + GetClassVersion());
if (m_TuningName.length() > 0)
- ssb.WriteItem(m_TuningName, "0", 1, WriteStr);
+ ssb.WriteItem(m_TuningName, "0", WriteStr);
ssb.WriteItem(m_EditMask, "1");
ssb.WriteItem(m_TuningType, "2");
if (m_NoteNameMap.size() > 0)
- ssb.WriteItem(m_NoteNameMap, "3", 1, WriteNoteMap);
+ ssb.WriteItem(m_NoteNameMap, "3", WriteNoteMap);
if (GetFineStepCount() > 0)
ssb.WriteItem(m_FineStepCount, "4");
@@ -488,9 +488,9 @@
if (GetGroupRatio() > 0)
ssb.WriteItem(m_GroupRatio, "RTI3");
if (tt == TT_GROUPGEOMETRIC)
- ssb.WriteItem(m_RatioTable, "RTI0", 4, RatioWriter(GetGroupSize()));
+ ssb.WriteItem(m_RatioTable, "RTI0", RatioWriter(GetGroupSize()));
if (tt == TT_GENERAL)
- ssb.WriteItem(m_RatioTable, "RTI0", 4, RatioWriter());
+ ssb.WriteItem(m_RatioTable, "RTI0", RatioWriter());
if (tt == TT_GEOMETRIC)
ssb.WriteItem(m_GroupSize, "RTI2");
Modified: trunk/OpenMPT/soundlib/tuningCollection.cpp
===================================================================
--- trunk/OpenMPT/soundlib/tuningCollection.cpp 2014-09-12 11:03:26 UTC (rev 4284)
+++ trunk/OpenMPT/soundlib/tuningCollection.cpp 2014-09-12 11:26:26 UTC (rev 4285)
@@ -108,12 +108,12 @@
{
srlztn::SsbWrite ssb(oStrm);
ssb.BeginWrite("TC", s_SerializationVersion);
- ssb.WriteItem(m_Name, "0", 1, &WriteStr);
+ ssb.WriteItem(m_Name, "0", &WriteStr);
ssb.WriteItem(m_EditMask, "1");
const size_t tcount = m_Tunings.size();
for(size_t i = 0; i<tcount; i++)
- ssb.WriteItem(*m_Tunings[i], "2", 1, &WriteTuning);
+ ssb.WriteItem(*m_Tunings[i], "2", &WriteTuning);
ssb.FinishWrite();
if(ssb.GetStatus() & srlztn::SNT_FAILURE)
@@ -176,11 +176,11 @@
for(srlztn::SsbRead::ReadIterator iter = iterBeg; iter != iterEnd; iter++)
{
if (ssb.CompareId(iter, "0") == srlztn::SsbRead::IdMatch)
- ssb.ReadItem(iter, m_Name, &ReadStr);
+ ssb.ReadIterItem(iter, m_Name, &ReadStr);
else if (ssb.CompareId(iter, "1") == srlztn::SsbRead::IdMatch)
- ssb.ReadItem(iter, m_EditMask);
+ ssb.ReadIterItem(iter, m_EditMask);
else if (ssb.CompareId(iter, "2") == srlztn::SsbRead::IdMatch)
- ssb.ReadItem(iter, *this, &ReadTuning);
+ ssb.ReadIterItem(iter, *this, &ReadTuning);
}
if(ssb.GetStatus() & srlztn::SNT_FAILURE)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
