puntoexe / Imebra / changeset / b8926cb540ff

puntoexe / Imebra (http://imebra.com/)

Imebra is a multiplatform open source C++ Dicom library from Puntoexe.

Clone this repository (size: 1.0 MB): HTTPS / SSH

$ hg clone http://bitbucket.org/puntoexe/imebra/

$ hg clone ssh://hg@bitbucket.org/puntoexe/imebra/

commit 123:	b8926cb540ff
parent 122:	7c6584da7c4d
branch:	default

- Fixes for the dataHandlers and base objects

pa...@puntoexe.com
9 months ago

Changed (Δ6.2 KB):

raw changeset »

project_files/base/include/baseObject.h (1 lines added, 1 lines removed)

project_files/base/include/baseStream.h (6 lines added, 6 lines removed)

project_files/base/include/charsetConversion.h (19 lines added, 19 lines removed)

project_files/base/include/exception.h (1 lines added, 1 lines removed)

project_files/base/include/huffmanTable.h (4 lines added, 4 lines removed)

project_files/base/include/memory.h (3 lines added, 3 lines removed)

project_files/base/include/memoryStream.h (1 lines added, 1 lines removed)

project_files/base/include/nullStream.h (1 lines added, 1 lines removed)

project_files/base/include/stream.h (3 lines added, 3 lines removed)

project_files/base/include/streamWriter.h (2 lines added, 2 lines removed)

project_files/base/src/baseObject.cpp (1 lines added, 1 lines removed)

project_files/base/src/charsetConversion.cpp (5 lines added, 5 lines removed)

project_files/base/src/exception.cpp (1 lines added, 1 lines removed)

project_files/base/src/huffmanTable.cpp (52 lines added, 52 lines removed)

project_files/base/src/memory.cpp (4 lines added, 4 lines removed)

project_files/base/src/memoryStream.cpp (2 lines added, 2 lines removed)

project_files/base/src/stream.cpp (3 lines added, 3 lines removed)

project_files/base/src/streamWriter.cpp (3 lines added, 3 lines removed)

project_files/examples/dicom2jpeg/nbproject/project.xml (3 lines added, 0 lines removed)

project_files/imebra/include/LUT.h (1 lines added, 1 lines removed)

project_files/imebra/include/buffer.h (4 lines added, 4 lines removed)

project_files/imebra/include/charsetsList.h (2 lines added, 2 lines removed)

project_files/imebra/include/dataHandler.h (28 lines added, 28 lines removed)

project_files/imebra/include/dataHandlerDate.h (6 lines added, 6 lines removed)

project_files/imebra/include/dataHandlerDateTime.h (5 lines added, 5 lines removed)

project_files/imebra/include/dataHandlerDateTimeBase.h (15 lines added, 15 lines removed)

project_files/imebra/include/dataHandlerNumeric.h (53 lines added, 53 lines removed)

project_files/imebra/include/dataHandlerString.h (32 lines added, 20 lines removed)

project_files/imebra/include/dataHandlerStringAE.h (3 lines added, 3 lines removed)

project_files/imebra/include/dataHandlerStringAS.h (11 lines added, 11 lines removed)

project_files/imebra/include/dataHandlerStringCS.h (3 lines added, 3 lines removed)

project_files/imebra/include/dataHandlerStringDS.h (8 lines added, 8 lines removed)

project_files/imebra/include/dataHandlerStringIS.h (5 lines added, 5 lines removed)

project_files/imebra/include/dataHandlerStringLO.h (3 lines added, 3 lines removed)

project_files/imebra/include/dataHandlerStringLT.h (5 lines added, 5 lines removed)

project_files/imebra/include/dataHandlerStringPN.h (4 lines added, 4 lines removed)

project_files/imebra/include/dataHandlerStringSH.h (3 lines added, 3 lines removed)

project_files/imebra/include/dataHandlerStringST.h (4 lines added, 4 lines removed)

project_files/imebra/include/dataHandlerStringUI.h (4 lines added, 4 lines removed)

project_files/imebra/include/dataHandlerStringUT.h (4 lines added, 4 lines removed)

project_files/imebra/include/dataHandlerStringUnicode.h (6 lines added, 6 lines removed)

project_files/imebra/include/dataHandlerTime.h (6 lines added, 6 lines removed)

project_files/imebra/include/image.h (7 lines added, 7 lines removed)

project_files/imebra/src/buffer.cpp (4 lines added, 4 lines removed)

project_files/imebra/src/charsetsList.cpp (5 lines added, 5 lines removed)

project_files/imebra/src/dataHandler.cpp (12 lines added, 68 lines removed)

project_files/imebra/src/dataHandlerDate.cpp (9 lines added, 9 lines removed)

project_files/imebra/src/dataHandlerDateTime.cpp (5 lines added, 5 lines removed)

project_files/imebra/src/dataHandlerDateTimeBase.cpp (42 lines added, 27 lines removed)

project_files/imebra/src/dataHandlerString.cpp (96 lines added, 31 lines removed)

Up to file-list project_files/base/include/baseObject.h:

@@ -320,7 +320,7 @@ public:
 	///                      to lock this one
 	///
 	///////////////////////////////////////////////////////////
-	baseObject(ptr<baseObject> externalLock);
+	baseObject(const ptr<baseObject>& externalLock);
 	/// \brief Creates the baseObject object and set an
 	///         external object to be used for the lock.

Up to file-list project_files/base/include/baseStream.h:

@@ -69,7 +69,7 @@ public:
 	///                        buffer that has to be written
 	///
 	///////////////////////////////////////////////////////////
-	virtual void write(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength) = 0;
+	virtual void write(imbxUint32 startPosition, const imbxUint8* pBuffer, imbxUint32 bufferLength) = 0;
 	/// \brief Read raw data from the stream.
 	///
@@ -102,7 +102,7 @@ public:
 class streamException: public std::runtime_error
+{
 public:
-	streamException(std::string message): std::runtime_error(message){}
+	streamException(const std::string& message): std::runtime_error(message){}
 };
@@ -115,7 +115,7 @@ public:
 class streamExceptionOpen : public streamException
+{
 public:
-	streamExceptionOpen(std::string message): streamException(message){}
+	streamExceptionOpen(const std::string& message): streamException(message){}
 };
@@ -129,7 +129,7 @@ public:
 class streamExceptionRead : public streamException
+{
 public:
-	streamExceptionRead(std::string message): streamException(message){}
+	streamExceptionRead(const std::string& message): streamException(message){}
 };
@@ -143,7 +143,7 @@ public:
 class streamExceptionWrite : public streamException
+{
 public:
-	streamExceptionWrite(std::string message): streamException(message){}
+	streamExceptionWrite(const std::string& message): streamException(message){}
 };
@@ -157,7 +157,7 @@ public:
 class streamExceptionClose : public streamException
+{
 public:
-	streamExceptionClose(std::string message): streamException(message){}
+	streamExceptionClose(const std::string& message): streamException(message){}
 };
 } // namespace puntoexe

Up to file-list project_files/base/include/charsetConversion.h:

 $fileHeader$
 */
 /*! \file charsetConversion.h
     \brief Declaration of the class used to convert a string between different
 	        charsets.
 The class hides the platform specific implementations and supplies a common
  interface for the charsets translations.
 */
 /*! \file charsetConversion.h
     \brief Declaration of the class used to convert a string between different
 	        charsets.
 The class hides the platform specific implementations and supplies a common
  interface for the charsets translations.
 */
 #if !defined(imebraCharsetConversion_3146DA5A_5276_4804_B9AB_A3D54C6B123A__INCLUDED_)
 #define imebraCharsetConversion_3146DA5A_5276_4804_B9AB_A3D54C6B123A__INCLUDED_
@@ -78,7 +78,7 @@ public:
 	///                   be used for the conversion
 	///
 	///////////////////////////////////////////////////////////
-	void initialize(std::string tableName);
+	void initialize(const std::string& tableName);
 	/// \brief Retrieve the ISO name of the charset currently
 	///         used for the conversion.
@@ -86,7 +86,7 @@ public:
 	/// @return the ISO name of the active charset
 	///
 	///////////////////////////////////////////////////////////
-	std::string getIsoCharset();
+	std::string getIsoCharset() const;
 	/// \brief Transform a multibyte string into an unicode
 	///         string using the charset declared with the
@@ -98,7 +98,7 @@ public:
 	/// @param unicodeStr
 	///
 	///////////////////////////////////////////////////////////
-	std::string fromUnicode(std::wstring unicodeString);
+	std::string fromUnicode(const std::wstring& unicodeString) const;
 	/// \brief Transform a multibyte string into an unicode
 	///         string using the charset declared with the
@@ -112,21 +112,21 @@ public:
 	/// @return            the converted unicode string
 	///
 	///////////////////////////////////////////////////////////
-	std::wstring toUnicode(std::string asciiString);
+	std::wstring toUnicode(const std::string& asciiString) const;
 protected:
 	void close();
-	int findTable(std::string tableName);
+	int findTable(const std::string& tableName) const;
 	std::string m_isoCharset;
 #if defined(PUNTOEXE_USEICONV)
 #if defined(WIN32)
-	std::string myIconv(iconv_t context, const char* inputString, size_t inputStringLengthBytes);
+	static std::string myIconv(iconv_t context, const char* inputString, size_t inputStringLengthBytes);
 #else
-	std::string myIconv(iconv_t context, char* inputString, size_t inputStringLengthBytes);
+	static std::string myIconv(iconv_t context, char* inputString, size_t inputStringLengthBytes);
 #endif
 	iconv_t m_iconvToUnicode;
 	iconv_t m_iconvFromUnicode;
@@ -187,7 +187,7 @@ protected:
 class charsetConversionException: public std::runtime_error
+{
 public:
-	charsetConversionException(std::string message): std::runtime_error(message){}
+	charsetConversionException(const std::string& message): std::runtime_error(message){}
 };
@@ -199,7 +199,7 @@ public:
 class charsetConversionExceptionNoTable: public charsetConversionException
+{
 public:
-	charsetConversionExceptionNoTable(std::string message): charsetConversionException(message){}
+	charsetConversionExceptionNoTable(const std::string& message): charsetConversionException(message){}
 };
@@ -211,7 +211,7 @@ public:
 class charsetConversionExceptionNoSupportedTable: public charsetConversionException
+{
 public:
-	charsetConversionExceptionNoSupportedTable(std::string message): charsetConversionException(message){}
+	charsetConversionExceptionNoSupportedTable(const std::string& message): charsetConversionException(message){}
 };
@@ -223,7 +223,7 @@ public:
 class charsetConversionExceptionUtfSizeNotSupported: public charsetConversionException
+{
 public:
-	charsetConversionExceptionUtfSizeNotSupported(std::string message): charsetConversionException(message){}
+	charsetConversionExceptionUtfSizeNotSupported(const std::string& message): charsetConversionException(message){}
 };

Up to file-list project_files/base/include/exception.h:

@@ -61,7 +61,7 @@ public:
 	///                       exception being rethrown
 	///
 	///////////////////////////////////////////////////////////
-	exceptionInfo(std::wstring functionName, std::string fileName, long lineNumber, std::string exceptionType, std::string exceptionMessage);
+	exceptionInfo(const std::wstring& functionName, const std::string& fileName, const long lineNumber, const std::string& exceptionType, const std::string& exceptionMessage);
 	exceptionInfo();

Up to file-list project_files/base/include/huffmanTable.h:

@@ -175,7 +175,7 @@ public:
 	///                  write the code
 	///
 	///////////////////////////////////////////////////////////
-	void writeHuffmanCode(imbxUint32* pBuffer, streamWriter* pStream);
+	void writeHuffmanCode(const imbxUint32* pBuffer, streamWriter* pStream);
 	//@}
@@ -245,19 +245,19 @@ public:
 class huffmanException: public std::runtime_error
+{
 public:
-	huffmanException(std::string message): std::runtime_error(message){}
+	huffmanException(const std::string& message): std::runtime_error(message){}
 };
 class huffmanExceptionRead : public huffmanException
+{
 public:
-	huffmanExceptionRead(std::string message): huffmanException(message){}
+	huffmanExceptionRead(const std::string& message): huffmanException(message){}
 };
 class huffmanExceptionWrite : public huffmanException
+{
 public:
-	huffmanExceptionWrite(std::string message): huffmanException(message){}
+	huffmanExceptionWrite(const std::string& message): huffmanException(message){}
 };

Up to file-list project_files/base/include/memory.h:

@@ -57,7 +57,7 @@ public:
 	///                      must be transferred
 	///
 	///////////////////////////////////////////////////////////
-	void transfer(ptr<memory> transferFrom);
+	void transfer(const ptr<memory>& transferFrom);
 	/// \brief Copy the content of the memory managed
 	///         by another memory object into the memory
@@ -67,7 +67,7 @@ public:
 	///                      which the data has to be copied
 	///
 	///////////////////////////////////////////////////////////
-	void copyFrom(ptr<memory> sourceMemory);
+	void copyFrom(const ptr<memory>& sourceMemory);
 	/// \brief Clear the content of the managed string of
 	///         bytes.
@@ -127,7 +127,7 @@ public:
 	///                      into the managed memory
 	///
 	///////////////////////////////////////////////////////////
-	void assign(imbxUint8* pSource, imbxUint32 sourceLength);
+	void assign(const imbxUint8* pSource, const imbxUint32 sourceLength);
 	/// \internal
 	/// \brief This function is called by

Up to file-list project_files/base/include/memoryStream.h:

@@ -53,7 +53,7 @@ public:
 	// Virtual stream's functions
 	//
 	///////////////////////////////////////////////////////////
-	virtual void write(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength);
+	virtual void write(imbxUint32 startPosition, const imbxUint8* pBuffer, imbxUint32 bufferLength);
 	virtual imbxUint32 read(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength);
 protected:

Up to file-list project_files/base/include/nullStream.h:

@@ -43,7 +43,7 @@ public:
 	// Virtual stream's functions
 	//
 	///////////////////////////////////////////////////////////
-	virtual void write(imbxUint32, imbxUint8*, imbxUint32){}
+	virtual void write(imbxUint32, const imbxUint8*, imbxUint32){}
 	virtual imbxUint32 read(imbxUint32 , imbxUint8* , imbxUint32 ){return 0;}
 };

Up to file-list project_files/base/include/stream.h:

@@ -74,16 +74,16 @@ public:
 	///                   the files ARE OPENED IN BINARY MODE.
 	///
 	///////////////////////////////////////////////////////////
-	void openFile(std::string fileName, int mode);
+	void openFile(const std::string& fileName, const int mode);
-	void openFile(std::wstring fileName, int mode);
+	void openFile(const std::wstring& fileName, const int mode);
 	///////////////////////////////////////////////////////////
 	//
 	// Virtual stream's functions
 	//
 	///////////////////////////////////////////////////////////
-	virtual void write(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength);
+	virtual void write(imbxUint32 startPosition, const imbxUint8* pBuffer, imbxUint32 bufferLength);
 	virtual imbxUint32 read(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength);
 protected:

Up to file-list project_files/base/include/streamWriter.h:

@@ -84,7 +84,7 @@ public:
 	///                   written to the stream
 	///
 	///////////////////////////////////////////////////////////
-	void write(imbxUint8* pBuffer, imbxUint32 bufferLength);
+	void write(const imbxUint8* pBuffer, imbxUint32 bufferLength);
 	/// \brief Write the specified amount of bits to the
 	///         stream.
@@ -102,7 +102,7 @@ public:
 	///                  The function can write 32 bits maximum
 	///
 	///////////////////////////////////////////////////////////
-	inline void writeBits(imbxUint32* const pBuffer, int bitsNum)
+	inline void writeBits(const imbxUint32* pBuffer, int bitsNum)
+	{
 		PUNTOEXE_FUNCTION_START(L"streamWriter::writeBits");

Up to file-list project_files/base/src/baseObject.cpp:


//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
baseObject::baseObject(ptr<baseObject> externalLock): m_externalLock(externalLock),
baseObject::baseObject(const ptr<baseObject>& externalLock): m_externalLock(externalLock),
	m_lockCounter(0), m_bValid(true), m_pExceptionsManager(exceptionsManager::getExceptionsManager())
{
}

Up to file-list project_files/base/src/charsetConversion.cpp:

@@ -77,7 +77,7 @@ charsetConversion::~charsetConversion()
 // Find the ID of the charset with the specified name
 //
 ///////////////////////////////////////////////////////////
-int charsetConversion::findTable(std::string tableName)
+int charsetConversion::findTable(const std::string& tableName) const
+{
 	PUNTOEXE_FUNCTION_START(L"charsetConversion::findTable");
@@ -100,7 +100,7 @@ int charsetConversion::findTable(std::st
 // Initialize the charsetConversion object
 //
 ///////////////////////////////////////////////////////////
-void charsetConversion::initialize(std::string tableName)
+void charsetConversion::initialize(const std::string& tableName)
+{
 	PUNTOEXE_FUNCTION_START(L"charsetConversion::initialize");
@@ -200,7 +200,7 @@ void charsetConversion::close()
 // Return the ISO name of the active charset
 //
 ///////////////////////////////////////////////////////////
-std::string charsetConversion::getIsoCharset()
+std::string charsetConversion::getIsoCharset() const
+{
 	return m_isoCharset;
+}
@@ -211,7 +211,7 @@ std::string charsetConversion::getIsoCha
 // Convert a string from unicode to multibyte
 //
 ///////////////////////////////////////////////////////////
-std::string charsetConversion::fromUnicode(std::wstring unicodeString)
+std::string charsetConversion::fromUnicode(const std::wstring& unicodeString) const
+{
 	PUNTOEXE_FUNCTION_START(L"charsetConversion::fromUnicode");
@@ -243,7 +243,7 @@ std::string charsetConversion::fromUnico
 // Convert a string from multibyte to unicode
 //
 ///////////////////////////////////////////////////////////
-std::wstring charsetConversion::toUnicode(std::string asciiString)
+std::wstring charsetConversion::toUnicode(const std::string& asciiString) const
+{
 	PUNTOEXE_FUNCTION_START(L"charsetConversion::toUnicode");

Up to file-list project_files/base/src/exception.cpp:

@@ -111,7 +111,7 @@ exceptionsManager* exceptionsManager::ge
 ///////////////////////////////////////////////////////////
 // Construct the exceptionInfo object
 ///////////////////////////////////////////////////////////
-exceptionInfo::exceptionInfo(std::wstring functionName, std::string fileName, long lineNumber, std::string exceptionType, std::string exceptionMessage):
+exceptionInfo::exceptionInfo(const std::wstring& functionName, const std::string& fileName, const long lineNumber, const std::string& exceptionType, const std::string& exceptionMessage):
 	m_functionName(functionName),
 	m_fileName(fileName),
 	m_lineNumber(lineNumber),

Up to file-list project_files/base/src/huffmanTable.cpp:

 #include "../include/streamWriter.h"
 #include <list>
-#include <string.h>
+#include <string.h>
 namespace puntoexe
+{
@@ -280,64 +280,64 @@ bool huffmanTable::readHuffmanCode(imbxU
 	// Buffer with the original huffman code
 	///////////////////////////////////////////////////////////
 	imbxUint32 readBuffer(0);
 	// Used to add multiple bits to the read buffer
 	///////////////////////////////////////////////////////////
 	// Used to add multiple bits to the read buffer
 	///////////////////////////////////////////////////////////
     imbxUint32 addBitsReadBuffer(0);
 	// Active ordered value
 	///////////////////////////////////////////////////////////
 	imbxUint32 orderedValue(0);
 	// Number of bits to read in one go
 	///////////////////////////////////////////////////////////
 	imbxUint32 orderedValue(0);
 	// Number of bits to read in one go
 	///////////////////////////////////////////////////////////
 	imbxUint8 missingBits(0);
 	// Scan all the codes sizes
 	///////////////////////////////////////////////////////////
 	for(imbxUint8 scanSize(1); scanSize<sizeof(m_valuesPerLength)/sizeof(m_valuesPerLength[0]); ++scanSize)
+	{
         ++missingBits;
 		// If the active length is empty, then continue the loop
 		///////////////////////////////////////////////////////////
 		if(m_valuesPerLength[scanSize] == 0)
+		{
 			continue;
+		}
 		// Read the missing bits
 		///////////////////////////////////////////////////////////
 		if(missingBits == scanSize) // Nothing in the buffer yet, we don't need to shift
+		{
 		    if(!pStream->readBits(&readBuffer, scanSize))
+		    {
 		        return false;
+		    }
+		}
 		else
+		{
 		    if(missingBits == 1)
+		    {
                 if(!pStream->addBit(&readBuffer))
+                {
                     return false;
+                }
+		    }
 		    else
+		    {
                 if(!pStream->readBits(&addBitsReadBuffer, missingBits))
+                {
                     return false;
+                }
 		        readBuffer <<= missingBits;
 		        readBuffer |= addBitsReadBuffer;
+		    }
+		}
 		// Reset the number of bits to read in one go
 		///////////////////////////////////////////////////////////
 		missingBits = 0;
+	{
         ++missingBits;
 		// If the active length is empty, then continue the loop
 		///////////////////////////////////////////////////////////
 		if(m_valuesPerLength[scanSize] == 0)
+		{
 			continue;
+		}
 		// Read the missing bits
 		///////////////////////////////////////////////////////////
 		if(missingBits == scanSize) // Nothing in the buffer yet, we don't need to shift
+		{
 		    if(!pStream->readBits(&readBuffer, scanSize))
+		    {
 		        return false;
+		    }
+		}
 		else
+		{
 		    if(missingBits == 1)
+		    {
                 if(!pStream->addBit(&readBuffer))
+                {
                     return false;
+                }
+		    }
 		    else
+		    {
                 if(!pStream->readBits(&addBitsReadBuffer, missingBits))
+                {
                     return false;
+                }
 		        readBuffer <<= missingBits;
 		        readBuffer |= addBitsReadBuffer;
+		    }
+		}
 		// Reset the number of bits to read in one go
 		///////////////////////////////////////////////////////////
 		missingBits = 0;
 		// Validate the current Huffman code. If it's OK, then
 		//  return the ordered value
@@ -367,7 +367,7 @@ bool huffmanTable::readHuffmanCode(imbxU
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void huffmanTable::writeHuffmanCode(imbxUint32* pBuffer, streamWriter* pStream)
+void huffmanTable::writeHuffmanCode(const imbxUint32* pBuffer, streamWriter* pStream)
+{
 	PUNTOEXE_FUNCTION_START(L"huffmanTable::writeHuffmanCode");

Up to file-list project_files/base/src/memory.cpp:

…	…	@@ -50,7 +50,7 @@ memory::memory():
50	50	//
51	51	///////////////////////////////////////////////////////////
52	52	///////////////////////////////////////////////////////////
53		void memory::transfer(~~ptr<memory>~~ transferFrom)
	53	void memory::transfer(const ptr<memory>& transferFrom)
54	54	{
55	55	m_pMemoryBuffer.reset(transferFrom->m_pMemoryBuffer.release());
56	56	}
…	…	@@ -65,7 +65,7 @@ void memory::transfer(ptr<memory> transf
65	65	//
66	66	///////////////////////////////////////////////////////////
67	67	///////////////////////////////////////////////////////////
68		void memory::copyFrom(~~ptr<memory>~~ sourceMemory)
	68	void memory::copyFrom(const ptr<memory>& sourceMemory)
69	69	{
70	70	if(m_pMemoryBuffer.get() == 0)
71	71	{
…	…	@@ -193,7 +193,7 @@ bool memory::empty()
193	193	//
194	194	///////////////////////////////////////////////////////////
195	195	///////////////////////////////////////////////////////////
196		void memory::assign(~~imbxUint8* pSource,~~ imbxUint32 sourceLength)
	196	void memory::assign(const imbxUint8* pSource, const imbxUint32 sourceLength)
197	197	{
198	198	if(m_pMemoryBuffer.get() == 0)
199	199	{
…	…	@@ -423,4 +423,4 @@ memory* memoryPool::getMemory(imbxUint32
423	423	return pMemory;
424	424	}
425	425
426		} // namespace puntoexe
	426	} // namespace puntoexe

Up to file-list project_files/base/src/memoryStream.cpp:

 #include "../include/exception.h"
 #include "../include/memoryStream.h"
-#include <string.h>
+#include <string.h>
 namespace puntoexe
+{
@@ -51,7 +51,7 @@ memoryStream::memoryStream(ptr<memory> m
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void memoryStream::write(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength)
+void memoryStream::write(imbxUint32 startPosition, const imbxUint8* pBuffer, imbxUint32 bufferLength)
+{
 	PUNTOEXE_FUNCTION_START(L"memoryStream::write");

Up to file-list project_files/base/src/stream.cpp:

@@ -56,7 +56,7 @@ stream::~stream()
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void stream::openFile(std::string fileName, int mode)
+void stream::openFile(const std::string& fileName, const int mode)
+{
 	PUNTOEXE_FUNCTION_START(L"stream::openFile (ansi)");
@@ -82,7 +82,7 @@ void stream::openFile(std::string fileNa
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void stream::openFile(std::wstring fileName, int mode)
+void stream::openFile(const std::wstring& fileName, const int mode)
+{
 	PUNTOEXE_FUNCTION_START(L"stream::openFile (unicode)");
 	if(m_openFile)
@@ -161,7 +161,7 @@ void stream::openFile(std::wstring fileN
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void stream::write(imbxUint32 startPosition, imbxUint8* pBuffer, imbxUint32 bufferLength)
+void stream::write(imbxUint32 startPosition, const imbxUint8* pBuffer, imbxUint32 bufferLength)
+{
 	PUNTOEXE_FUNCTION_START(L"stream::write");

Up to file-list project_files/base/src/streamWriter.cpp:

 */
-#include "../include/streamWriter.h"
+#include "../include/streamWriter.h"
 #include <string.h>
 namespace puntoexe
@@ -19,7 +19,7 @@ namespace puntoexe
 //
 ///////////////////////////////////////////////////////////
 streamWriter::streamWriter(ptr<baseStream> pControlledStream, imbxUint32 virtualStart /* =0 */, imbxUint32 virtualLength /* =0 */):
-	streamController(pControlledStream, virtualStart, virtualLength),
+	streamController(pControlledStream, virtualStart, virtualLength),
 	m_outBitsBuffer(0),
 	m_outBitsNum(0)
+{
@@ -60,7 +60,7 @@ void streamWriter::flushDataBuffer()
 // Write into the stream
 //
 ///////////////////////////////////////////////////////////
-void streamWriter::write(imbxUint8* pBuffer, imbxUint32 bufferLength)
+void streamWriter::write(const imbxUint8* pBuffer, imbxUint32 bufferLength)
+{
 	while(bufferLength != 0)
+	{

Up to file-list project_files/examples/dicom2jpeg/nbproject/project.xml:

             <name>dicom2jpeg</name>
             <make-project-type>0</make-project-type>
             <make-dep-projects/>
             <c-extensions/>
             <cpp-extensions>cpp</cpp-extensions>
             <header-extensions>h</header-extensions>
         </data>
     </configuration>
 </project>

Up to file-list project_files/imebra/include/LUT.h:

@@ -53,7 +53,7 @@ public:
 		m_firstMapped(0),
 		m_bits(0),
 		m_bChecked(false),
-		m_bValid(false),
+		m_bValid(false),
 		m_pMappedValues(0){}

Up to file-list project_files/imebra/include/buffer.h:

@@ -88,7 +88,7 @@ public:
 	///                      two uppercase chars
 	///
 	///////////////////////////////////////////////////////////
-	buffer(ptr<baseObject> externalLock, std::string defaultType="");
+	buffer(const ptr<baseObject>& externalLock, const std::string& defaultType="");
 	/// \brief Constructor. Initialize the buffer object and
 	///         declare the buffer's content on demand.
@@ -118,9 +118,9 @@ public:
 	/// @param endianType   the stream's endian type
 	///
 	///////////////////////////////////////////////////////////
 	buffer(ptr<baseObject> externalLock,
 		std::string defaultType,
-		ptr<baseStream> originalStream,
+	buffer(const ptr<baseObject>& externalLock,
 		const std::string& defaultType,
 		const ptr<baseStream>& originalStream,
 		imbxUint32 bufferPosition,
 		imbxUint32 bufferLength,
 		imbxUint32 wordLength,

Up to file-list project_files/imebra/include/charsetsList.h:

@@ -43,8 +43,8 @@ typedef std::list<std::wstring> tCharset
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
 void updateCharsets(tCharsetsList* pCharsetsList, tCharsetsList* pDestinationCharsetsList);
 void copyCharsets(tCharsetsList* pSourceCharsetsList, tCharsetsList* pDestinationCharsetsList);
 void updateCharsets(const tCharsetsList* pCharsetsList, tCharsetsList* pDestinationCharsetsList);
 void copyCharsets(const tCharsetsList* pSourceCharsetsList, tCharsetsList* pDestinationCharsetsList);
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////

Up to file-list project_files/imebra/include/dataHandler.h:

@@ -142,7 +142,7 @@ public:
 	/// @param elementNumber The element number to activate.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setPointer(imbxUint32 elementNumber) =0;
+	virtual void setPointer(const imbxUint32 elementNumber) =0;
 	/// \brief Increase the internal pointer by one element.
 	///
@@ -165,7 +165,7 @@ public:
 	///             current value of the data handler's
 	///             internal pointer
 	///////////////////////////////////////////////////////////
-	virtual void skip(int skip);
+	virtual void skip(const int skip);
 	/// \brief Returns true if the data handler's internal
 	///        pointer is valid.
@@ -182,7 +182,7 @@ public:
 	///         false=invalid).
 	///
 	///////////////////////////////////////////////////////////
-	virtual bool pointerIsValid() =0;
+	virtual bool pointerIsValid() const=0;
 	//@}
@@ -202,7 +202,7 @@ public:
 	///                        in data elements
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setSize(imbxUint32 elementsNumber) =0;
+	virtual void setSize(const imbxUint32 elementsNumber) =0;
 	/// \brief Retrieve the data handler's local buffer buffer
 	///         size (in elements).
@@ -210,7 +210,7 @@ public:
 	/// @return the buffer's size in elements
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getSize() =0;
+	virtual imbxUint32 getSize() const=0;
 	/// \brief Returns a single element's size in bytes.
 	///
@@ -221,7 +221,7 @@ public:
 	///         element doesn't have a fixed size
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnitSize() =0;
+	virtual imbxUint32 getUnitSize() const=0;
 	//@}
@@ -240,7 +240,7 @@ public:
 	///                      \ref buffer
 	///
 	///////////////////////////////////////////////////////////
-	virtual void parseBuffer(ptr<memory> memoryBuffer)=0;
+	virtual void parseBuffer(const ptr<memory>& memoryBuffer)=0;
 	/// \internal
 	/// \brief This function copies the %data from the
@@ -252,7 +252,7 @@ public:
 	///                 pBuffer
 	///
 	///////////////////////////////////////////////////////////
-	void parseBuffer(imbxUint8* pBuffer, imbxUint32 bufferLength);
+	void parseBuffer(const imbxUint8* pBuffer, const imbxUint32 bufferLength);
 	/// \internal
 	/// \brief Copies the local %buffer into the original
@@ -262,7 +262,7 @@ public:
 	///                      \ref buffer
 	///
 	///////////////////////////////////////////////////////////
-	virtual void buildBuffer(ptr<memory> memoryBuffer)=0;
+	virtual void buildBuffer(const ptr<memory>& memoryBuffer)=0;
 	/// \internal
 	/// \brief Defines the charsets used in the string
@@ -279,7 +279,7 @@ public:
 	///                      dicom charsets used in the string
 	///
 	///////////////////////////////////////////////////////////
-	virtual void getCharsetsList(charsetsList::tCharsetsList* pCharsetsList);
+	virtual void getCharsetsList(charsetsList::tCharsetsList* pCharsetsList) const;
 	//@}
@@ -299,7 +299,7 @@ public:
 	/// @return the data handler's dicom data type
 	///
 	///////////////////////////////////////////////////////////
-	std::string getDataType();
+	std::string getDataType() const;
 	/// \brief Return the byte that this handler uses to fill
 	///         its content to make its size even.
@@ -307,7 +307,7 @@ public:
 	/// @return the byte used to make the content's size even
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
 	//@}
@@ -329,7 +329,7 @@ public:
 	///          transformed into a signed long
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxInt32 getSignedLong() =0;
+	virtual imbxInt32 getSignedLong() const=0;
 	/// \brief Retrieve the active %data element as an unsigned
 	///         long.
@@ -342,7 +342,7 @@ public:
 	///          transformed into an unsigned long
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnsignedLong() =0;
+	virtual imbxUint32 getUnsignedLong() const =0;
 	/// \brief Retrieve the active %data element as a double.
 	///
@@ -354,7 +354,7 @@ public:
 	///          transformed into a double
 	///
 	///////////////////////////////////////////////////////////
-	virtual double getDouble() =0;
+	virtual double getDouble() const=0;
 	/// \brief Retrieve the active %data element as a signed
 	///         long and increase the %data handler's internal
@@ -414,7 +414,7 @@ public:
 	///         transformed into a string.
 	///
 	///////////////////////////////////////////////////////////
-	virtual std::string getString() = 0;
+	virtual std::string getString() const= 0;
 	/// \brief Retrieve the active %data element as an
 	///         unicode string.
@@ -431,7 +431,7 @@ public:
 	///         transformed into a string.
 	///
 	///////////////////////////////////////////////////////////
-	virtual std::wstring getUnicodeString() = 0;
+	virtual std::wstring getUnicodeString() const = 0;
 	/// \brief Retrieve the active %data element as a date.
 	///
@@ -470,7 +470,7 @@ public:
 		imbxInt32* pSeconds,
 		imbxInt32* pNanoseconds,
 		imbxInt32* pOffsetHours,
-		imbxInt32* pOffsetMinutes);
+		imbxInt32* pOffsetMinutes) const;
 	/// \brief Set the active %data element as a date.
 	///
@@ -513,7 +513,7 @@ public:
 	///				  %data element.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLong(imbxInt32 value) =0;
+	virtual void setSignedLong(const imbxInt32 value) =0;
 	/// \brief Set the active %data element from an unsigned
 	///        long.
@@ -526,7 +526,7 @@ public:
 	///				  %data element.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLong(imbxUint32 value) =0;
+	virtual void setUnsignedLong(const imbxUint32 value) =0;
 	/// \brief Set the active %data element from a double
 	///
@@ -538,7 +538,7 @@ public:
 	///				  %data element.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setDouble(double value) =0;
+	virtual void setDouble(const double value) =0;
 	/// \brief Set the active %data element from a signed
 	///         long and increase the data handler's internal
@@ -552,7 +552,7 @@ public:
 	///				  %data element.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLongIncPointer(imbxInt32 value);
+	virtual void setSignedLongIncPointer(const imbxInt32 value);
 	/// \brief Set the active %data element from an unsigned
 	///         long and increase the data handler's internal
@@ -566,7 +566,7 @@ public:
 	///				  %data element.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLongIncPointer(imbxUint32 value);
+	virtual void setUnsignedLongIncPointer(const imbxUint32 value);
 	/// \brief Set the active %data element from a double
 	///         and increase the data handler's internal
@@ -580,7 +580,7 @@ public:
 	///				  %data element.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setDoubleIncPointer(double value);
+	virtual void setDoubleIncPointer(const double value);
 	/// \brief Set the active %data element from a string.
 	///        SetUnicodeString() is preferred over
@@ -593,7 +593,7 @@ public:
 	/// @param value the value to write into the active
 	///				  %data element.
 	///////////////////////////////////////////////////////////
-	virtual void setString(std::string value) =0;
+	virtual void setString(const std::string& value) =0;
 	/// \brief Set the active %data element from an unicode
 	///          string.
@@ -608,7 +608,7 @@ public:
 	/// @param value the value to write into the active
 	///				  %data element.
 	///////////////////////////////////////////////////////////
-	virtual void setUnicodeString(std::wstring value) =0;
+	virtual void setUnicodeString(const std::wstring& value) =0;
 	//@}
@@ -635,7 +635,7 @@ public:
 	///                      handler.
 	///
 	///////////////////////////////////////////////////////////
-	virtual void copyFromInt32(imbxInt32* pSource, imbxUint32 length);
+	virtual void copyFromInt32(const imbxInt32* pSource, const imbxUint32 length) = 0;
 	/// \brief Copy the content of the %buffer controlled by
 	///         the handler into an array of imbxInt32 values.
@@ -646,7 +646,7 @@ public:
 	///                      copy into the destination array
 	///
 	///////////////////////////////////////////////////////////
-	virtual void copyToInt32(imbxInt32* pDest, imbxUint32 length);
+	virtual void copyToInt32(imbxInt32* pDest, const imbxUint32 length) const = 0;
 	//@}

Up to file-list project_files/imebra/include/dataHandlerDate.h:

@@ -39,7 +39,7 @@ namespace handlers
 class dataHandlerDate : public dataHandlerDateTimeBase
+{
 public:
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 	virtual void getDate(
 		imbxInt32* pYear,
@@ -50,7 +50,7 @@ public:
 		imbxInt32* pSeconds,
 		imbxInt32* pNanoseconds,
 		imbxInt32* pOffsetHours,
-		imbxInt32* pOffsetMinutes);
+		imbxInt32* pOffsetMinutes) const;
 	virtual void setDate(
 		imbxInt32 year,
@@ -76,7 +76,7 @@ public:
 	///          buffer
 	///
 	///////////////////////////////////////////////////////////
-	virtual std::wstring getUnicodeString();
+	virtual std::wstring getUnicodeString() const;
 	/// \brief Set the date from a string.
 	///
@@ -89,12 +89,12 @@ public:
 	/// @param value the string representing the date to be set
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setUnicodeString(std::wstring value);
+	virtual void setUnicodeString(const std::wstring& value);
-	void parseBuffer(ptr<memory> memoryBuffer);
+	void parseBuffer(const ptr<memory>& memoryBuffer);
 protected:
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerDateTime.h:

@@ -40,7 +40,7 @@ public:
 		imbxInt32* pSeconds,
 		imbxInt32* pNanoseconds,
 		imbxInt32* pOffsetHours,
-		imbxInt32* pOffsetMinutes);
+		imbxInt32* pOffsetMinutes) const;
 	virtual void setDate(
 		imbxInt32 year,
@@ -71,7 +71,7 @@ public:
 	///          buffer
 	///
 	///////////////////////////////////////////////////////////
-	virtual std::wstring getUnicodeString();
+	virtual std::wstring getUnicodeString() const;
 	/// \brief Set the date from a string.
 	///
@@ -89,12 +89,12 @@ public:
 	/// @param value the string representing the date to be set
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setUnicodeString(std::wstring value);
+	virtual void setUnicodeString(const std::wstring& value);
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerDateTimeBase.h:

@@ -42,35 +42,35 @@ namespace handlers
 class dataHandlerDateTimeBase : public dataHandlerString {
 public:
 	virtual imbxInt32 getSignedLong();
 	virtual imbxUint32 getUnsignedLong();
 	virtual double getDouble();
 	virtual void setSignedLong(imbxInt32 value);
 	virtual void setUnsignedLong(imbxUint32 value);
 	virtual void setDouble(double value);
 	virtual imbxInt32 getSignedLong() const;
 	virtual imbxUint32 getUnsignedLong() const;
 	virtual double getDouble() const;
 	virtual void setSignedLong(const imbxInt32 value);
 	virtual void setUnsignedLong(const imbxUint32 value);
 	virtual void setDouble(const double value);
 protected:
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 	void parseDate(
-		std::wstring dateString,
+		std::wstring dateString,
 		imbxInt32* pYear,
 		imbxInt32* pMonth,
-		imbxInt32* pDay);
+		imbxInt32* pDay) const;
 	std::wstring buildDate(
 		imbxUint32 year,
 		imbxUint32 month,
-		imbxUint32 day);
+		imbxUint32 day) const;
 	void parseTime(
-		std::wstring timeString,
+		std::wstring timeString,
 		imbxInt32* pHour,
 		imbxInt32* pMinutes,
 		imbxInt32* pSeconds,
 		imbxInt32* pNanoseconds,
 		imbxInt32* pOffsetHours,
-		imbxInt32* pOffsetMinutes);
+		imbxInt32* pOffsetMinutes) const;
 	std::wstring buildTime(
 		imbxInt32 hour,
@@ -79,10 +79,10 @@ protected:
 		imbxInt32 nanoseconds,
 		imbxInt32 offsetHours,
 		imbxInt32 offsetMinutes
-		);
+		) const;
 	void split(std::wstring timeString, std::wstring separators, std::vector<std::wstring> *pComponents);
 	std::wstring padLeft(std::wstring source, std::wstring fillChar, size_t length);
 	void split(const std::wstring& timeString, const std::wstring& separators, std::vector<std::wstring> *pComponents) const;
 	std::wstring padLeft(const std::wstring& source, const wchar_t fillChar, const size_t length) const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerNumeric.h:

@@ -78,14 +78,14 @@ public:
 	// Returns the size of an element managed by the
 	//  handler.
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnitSize()
+	virtual imbxUint32 getUnitSize() const
+	{
 		return sizeof(dataHandlerType);
+	}
 	// Set the data element's pointer
 	///////////////////////////////////////////////////////////
-	virtual void setPointer(imbxUint32 elementNumber)
+	virtual void setPointer(const imbxUint32 elementNumber)
+	{
 		if(m_pMemoryString == 0 || elementNumber >= getSize())
+		{
@@ -103,7 +103,7 @@ public:
 	// Returns true if the pointer is valid
 	///////////////////////////////////////////////////////////
-	virtual bool pointerIsValid()
+	virtual bool pointerIsValid() const
+	{
 		return m_elementPointer != 0 && m_elementPointer < (dataHandlerType*)m_pMemoryStringEnd;
+	}
@@ -111,28 +111,28 @@ public:
 	// Increase the data element's pointer by the specified
 	//  amount of steps
 	///////////////////////////////////////////////////////////
-	virtual void skip(int skip)
+	virtual void skip(const int skip)
+	{
-		m_elementPointer+=skip;
+		m_elementPointer += skip;
+	}
 	// Retrieve the data element as a signed long
 	///////////////////////////////////////////////////////////
-	virtual imbxInt32 getSignedLong()
+	virtual imbxInt32 getSignedLong() const
+	{
 		return (imbxInt32) (*m_elementPointer);
+	}
 	// Retrieve the data element an unsigned long
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnsignedLong()
+	virtual imbxUint32 getUnsignedLong() const
+	{
 		return (imbxUint32) (*m_elementPointer);
+	}
 	// Retrieve the data element as a double
 	///////////////////////////////////////////////////////////
-	virtual double getDouble()
+	virtual double getDouble() const
+	{
 		return (double) (*m_elementPointer);
+	}
@@ -163,7 +163,7 @@ public:
 	// Retrieve the data element as a string
 	///////////////////////////////////////////////////////////
-	virtual std::string getString()
+	virtual std::string getString() const
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::getString");
@@ -176,7 +176,7 @@ public:
 	// Retrieve the data element as a unicode string
 	///////////////////////////////////////////////////////////
-	virtual std::wstring getUnicodeString()
+	virtual std::wstring getUnicodeString() const
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::getUnicodeString");
@@ -189,7 +189,7 @@ public:
 	// Retrieve the buffer's size in elements
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getSize()
+	virtual imbxUint32 getSize() const
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::getSize");
@@ -200,21 +200,21 @@ public:
 	// Set the data element as a signed long
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLong(imbxInt32 value)
+	virtual void setSignedLong(const imbxInt32 value)
+	{
 		*m_elementPointer = (dataHandlerType)value;
+	}
 	// Set the data element as an unsigned long
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLong(imbxUint32 value)
+	virtual void setUnsignedLong(const imbxUint32 value)
+	{
 		*m_elementPointer = (dataHandlerType)value;
+	}
 	// Set the data element as a double
 	///////////////////////////////////////////////////////////
-	virtual void setDouble(double value)
+	virtual void setDouble(const double value)
+	{
 		*m_elementPointer = (dataHandlerType)value;
+	}
@@ -222,7 +222,7 @@ public:
 	// Set the data element as a signed long and increase the
 	//  data element's pointer
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLongIncPointer(imbxInt32 value)
+	virtual void setSignedLongIncPointer(const imbxInt32 value)
+	{
 		*(m_elementPointer++) = (dataHandlerType)value;
+	}
@@ -230,7 +230,7 @@ public:
 	// Set the data element as an unsigned long and increase
 	//  the data element's pointer
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLongIncPointer(imbxUint32 value)
+	virtual void setUnsignedLongIncPointer(const imbxUint32 value)
+	{
 		*(m_elementPointer++) = (dataHandlerType)value;
+	}
@@ -238,14 +238,14 @@ public:
 	// Set the data element as a double and increase the data
 	//  element's pointer
 	///////////////////////////////////////////////////////////
-	virtual void setDoubleIncPointer(double value)
+	virtual void setDoubleIncPointer(const double value)
+	{
 		*(m_elementPointer++) = (dataHandlerType)value;
+	}
 	// Set the data element as a string
 	///////////////////////////////////////////////////////////
-	virtual void setString(std::string value)
+	virtual void setString(const std::string& value)
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::setString");
@@ -259,7 +259,7 @@ public:
 	// Set the data element as an unicode string
 	///////////////////////////////////////////////////////////
-	virtual void setUnicodeString(std::wstring value)
+	virtual void setUnicodeString(const std::wstring& value)
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::setUnicodeString");
@@ -281,7 +281,7 @@ public:
 	///          the data managed by the handler
 	///
 	///////////////////////////////////////////////////////////
-	dataHandlerType* getMemoryBuffer()
+	dataHandlerType* getMemoryBuffer() const
+	{
 		return m_pMemoryString;
+	}
@@ -301,7 +301,7 @@ public:
 	// Copy the data from an array of imbxInt32 values
 	//  into the memory managed by the handler.
 	///////////////////////////////////////////////////////////
-	virtual void copyFromInt32(imbxInt32* pSource, imbxUint32 length)
+	virtual void copyFromInt32(const imbxInt32* pSource, const imbxUint32 length)
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::copyFromInt32");
@@ -322,7 +322,7 @@ public:
 	// Copy the data from the handler into an array of
 	//  imbxInt32 values
 	///////////////////////////////////////////////////////////
-	virtual void copyToInt32(imbxInt32* pDest, imbxUint32 length)
+	virtual void copyToInt32(imbxInt32* pDest, const imbxUint32 length) const
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::copyToInt32");
@@ -377,7 +377,7 @@ public:
 	///                      destination buffer
 	///
 	///////////////////////////////////////////////////////////
-	virtual void copyFromInt32Interleaved(imbxInt32* pSource,
+	virtual void copyFromInt32Interleaved(const imbxInt32* pSource,
 		imbxUint32 sourceReplicateX,
 		imbxUint32 sourceReplicateY,
 		imbxUint32 destStartCol,
@@ -394,42 +394,42 @@ public:
 			return;
+		}
 		dataHandlerType *pDestRowScan = &(m_pMemoryString[(destStartRow*destWidth+destStartCol)*destNumChannels+destStartChannel]);
-		imbxInt32* pSourceRowScan = pSource;
+		const imbxInt32* pSourceRowScan = pSource;
 		imbxUint32 replicateXCount;
 		imbxUint32 replicateYCount = sourceReplicateY;
 		imbxUint32 replicateYIncrease = (destEndCol - destStartCol) / sourceReplicateX;
 		dataHandlerType *pDestColScan;
-		imbxInt32* pSourceColScan;
+		const imbxInt32* pSourceColScan;
         if(destHeight < destEndRow)
+        {
             destEndRow = destHeight;
+        }
         if(destWidth < destEndCol)
+        {
             destEndCol = destWidth;
+        }
         imbxUint32 numColumns(destEndCol - destStartCol);
         imbxUint32 scanCol(0); // Used in the loop to scan the columns
         if(destHeight < destEndRow)
+        {
             destEndRow = destHeight;
+        }
         if(destWidth < destEndCol)
+        {
             destEndCol = destWidth;
+        }
         imbxUint32 numColumns(destEndCol - destStartCol);
         imbxUint32 scanCol(0); // Used in the loop to scan the columns
 		for(imbxUint32 numYCopies(destEndRow - destStartRow); numYCopies != 0; --numYCopies)
+		{
 			pDestColScan = pDestRowScan;
 			pSourceColScan = pSourceRowScan;
             if(sourceReplicateX == 1)
+            {
                 for(scanCol = numColumns; scanCol != 0; --scanCol)
+                {
                     *pDestColScan = (dataHandlerType)(*(pSourceColScan++));
                     pDestColScan += destNumChannels;
+                }
+            }
             else
+            {
                 replicateXCount = sourceReplicateX;
             if(sourceReplicateX == 1)
+            {
                 for(scanCol = numColumns; scanCol != 0; --scanCol)
+                {
                     *pDestColScan = (dataHandlerType)(*(pSourceColScan++));
                     pDestColScan += destNumChannels;
+                }
+            }
             else
+            {
                 replicateXCount = sourceReplicateX;
                 for(scanCol = numColumns; scanCol != 0; --scanCol)
+                {
                     *pDestColScan = (dataHandlerType)(*pSourceColScan);
@@ -439,7 +439,7 @@ public:
                         replicateXCount = sourceReplicateX;
                         ++pSourceColScan;
+                    }
+                }
+                }
+            }
 			pDestRowScan += destWidth * destNumChannels;
 			if(--replicateYCount == 0)
@@ -497,7 +497,7 @@ public:
 		imbxUint32 sourceStartChannel,
 		imbxUint32 sourceWidth,
 		imbxUint32 sourceHeight,
-		imbxUint32 sourceNumChannels)
+		imbxUint32 sourceNumChannels) const
+	{
 		if(sourceStartCol >= sourceWidth || sourceStartRow >= sourceHeight)
+		{
@@ -568,7 +568,7 @@ public:
 	// Set the buffer's size, in data elements
 	///////////////////////////////////////////////////////////
-	virtual void setSize(imbxUint32 elementsNumber)
+	virtual void setSize(const imbxUint32 elementsNumber)
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::setSize");
@@ -582,7 +582,7 @@ public:
 	// Parse the tag's buffer and extract its content
 	///////////////////////////////////////////////////////////
-	virtual void parseBuffer(ptr<memory> memoryBuffer)
+	virtual void parseBuffer(const ptr<memory>& memoryBuffer)
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::parseBuffer");
@@ -595,7 +595,7 @@ public:
 	// Rebuild the tag's buffer
 	///////////////////////////////////////////////////////////
-	virtual void buildBuffer(ptr<memory> memoryBuffer)
+	virtual void buildBuffer(const ptr<memory>& memoryBuffer)
+	{
 		PUNTOEXE_FUNCTION_START(L"dataHandlerNumeric::buildBuffer");

Up to file-list project_files/imebra/include/dataHandlerString.h:

@@ -46,7 +46,7 @@ public:
 public:
 	// Set the data element's pointer
 	///////////////////////////////////////////////////////////
-	virtual void setPointer(imbxUint32 elementNumber);
+	virtual void setPointer(imbxUint32 const elementNumber);
 	// Increase the data element's pointer
 	///////////////////////////////////////////////////////////
@@ -54,82 +54,94 @@ public:
 	// Returns true if the pointer is valid
 	///////////////////////////////////////////////////////////
-	virtual bool pointerIsValid();
+	virtual bool pointerIsValid() const;
 	// Get the data element as a signed long
 	///////////////////////////////////////////////////////////
-	virtual imbxInt32 getSignedLong();
+	virtual imbxInt32 getSignedLong() const;
 	// Get the data element as an unsigned long
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnsignedLong();
+	virtual imbxUint32 getUnsignedLong() const;
 	// Get the data element as a double
 	///////////////////////////////////////////////////////////
-	virtual double getDouble();
+	virtual double getDouble() const;
 	// Get the data element as a string
 	///////////////////////////////////////////////////////////
-	virtual std::string getString();
+	virtual std::string getString() const;
 	// Get the data element as an unicode string
 	///////////////////////////////////////////////////////////
-	virtual std::wstring getUnicodeString();
+	virtual std::wstring getUnicodeString() const;
 	// Retrieve the data element as a string
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getSize();
+	virtual imbxUint32 getSize() const;
 	// Set the data element as a signed long
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLong(imbxInt32 value);
+	virtual void setSignedLong(const imbxInt32 value);
 	// Set the data element as an unsigned long
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLong(imbxUint32 value);
+	virtual void setUnsignedLong(const imbxUint32 value);
 	// Set the data element as a double
 	///////////////////////////////////////////////////////////
-	virtual void setDouble(double value);
+	virtual void setDouble(const double value);
 	// Set the data element as a string
 	///////////////////////////////////////////////////////////
-	virtual void setString(std::string value);
+	virtual void setString(const std::string& value);
 	// Set the data element as an unicode string
 	///////////////////////////////////////////////////////////
-	virtual void setUnicodeString(std::wstring value);
+	virtual void setUnicodeString(const std::wstring& value);
 	// Set the buffer's size, in data elements
 	///////////////////////////////////////////////////////////
-	virtual void setSize(imbxUint32 elementsNumber);
+	virtual void setSize(const imbxUint32 elementsNumber);
 	// Parse the buffer
 	///////////////////////////////////////////////////////////
-	virtual void parseBuffer(ptr<memory> memoryBuffer);
+	virtual void parseBuffer(const ptr<memory>& memoryBuffer);
 	// Build the buffer
 	///////////////////////////////////////////////////////////
-	virtual void buildBuffer(ptr<memory> memoryBuffer);
+	virtual void buildBuffer(const ptr<memory>& memoryBuffer);
 	// Copy the content of an array of imbxInt32 values
 	//         into the buffer controlled by the handler.
 	///////////////////////////////////////////////////////////
 	virtual void copyFromInt32(const imbxInt32* pSource, const imbxUint32 length);
 	// Copy the content of the buffer to an array of imbxInt32
 	//         values.
 	///////////////////////////////////////////////////////////
 	///////////////////////////////////////////////////////////
 	virtual void copyToInt32(imbxInt32* pDest, const imbxUint32 length) const;
 protected:
 	// Convert a string to unicode, without using the dicom
 	//  charsets
 	///////////////////////////////////////////////////////////
-	virtual std::wstring convertToUnicode(std::string value);
+	virtual std::wstring convertToUnicode(const std::string& value) const;
 	// Convert a string from unicode, without using the dicom
 	//  charsets
 	///////////////////////////////////////////////////////////
-	virtual std::string convertFromUnicode(std::wstring value);
+	virtual std::string convertFromUnicode(const std::wstring& value, charsetsList::tCharsetsList* pCharsetsList) const;
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 	// Return the separator
 	///////////////////////////////////////////////////////////
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 	imbxUint32 m_elementNumber;

Up to file-list project_files/imebra/include/dataHandlerStringAE.h:

@@ -40,14 +40,14 @@ namespace handlers
 class dataHandlerStringAE : public dataHandlerString
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringAS.h:

@@ -67,7 +67,7 @@ public:
 	/// @param unit  the units used for the parameter age
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setAge(imbxUint32 age, tAgeUnit unit);
+	virtual void setAge(const imbxUint32 age, const tAgeUnit unit);
 	/// \brief Retrieve the age value and its unit from the
 	///         buffer handled by this handler.
@@ -80,7 +80,7 @@ public:
 	///               pUnit
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getAge(tAgeUnit* pUnit);
+	virtual imbxUint32 getAge(tAgeUnit* pUnit) const;
 	/// \brief Retrieve the age from the handled buffer.
 	///
@@ -90,7 +90,7 @@ public:
 	///          years
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxInt32 getSignedLong();
+	virtual imbxInt32 getSignedLong() const;
 	/// \brief Retrieve the age from the handled buffer.
 	///
@@ -100,7 +100,7 @@ public:
 	///          years
 	///
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnsignedLong();
+	virtual imbxUint32 getUnsignedLong() const;
 	/// \brief Retrieve the age from the handled buffer.
 	///
@@ -113,21 +113,21 @@ public:
 	///          years
 	///
 	///////////////////////////////////////////////////////////
-	virtual double getDouble();
+	virtual double getDouble() const;
 	/// \brief Write the specified age into the handled buffer.
 	///
 	/// @param value the age to be written, in years
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLong(imbxInt32 value);
+	virtual void setSignedLong(const imbxInt32 value);
 	/// \brief Write the specified age into the handled buffer.
 	///
 	/// @param value the age to be written, in years
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLong(imbxUint32 value);
+	virtual void setUnsignedLong(const imbxUint32 value);
 	/// \brief Write the specified age into the handled buffer.
 	///
@@ -138,17 +138,17 @@ public:
 	/// @param value the age to be written, in years
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setDouble(double value);
+	virtual void setDouble(const double value);
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringCS.h:

@@ -37,14 +37,14 @@ namespace handlers
 class dataHandlerStringCS : public dataHandlerString
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringDS.h:

@@ -38,36 +38,36 @@ class dataHandlerStringDS : public dataH
 public:
 	// Overwritten to use getDouble()
 	///////////////////////////////////////////////////////////
-	virtual imbxInt32 getSignedLong();
+	virtual imbxInt32 getSignedLong() const;
 	// Overwritten to use getDouble()
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnsignedLong();
+	virtual imbxUint32 getUnsignedLong() const;
 	// Overwritten to use setDouble()
 	///////////////////////////////////////////////////////////
-	virtual void setSignedLong(imbxInt32 value);
+	virtual void setSignedLong(const imbxInt32 value);
 	// Overwritten to use setDouble()
 	///////////////////////////////////////////////////////////
-	virtual void setUnsignedLong(imbxUint32 value);
+	virtual void setUnsignedLong(const imbxUint32 value);
 	// Overwritten to use the exponential form if needed
 	///////////////////////////////////////////////////////////
-	virtual void setDouble(double value);
+	virtual void setDouble(const double value);
 	// Get the padding byte
 	///////////////////////////////////////////////////////////
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
 	// Get the element size
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };

Up to file-list project_files/imebra/include/dataHandlerStringIS.h:

@@ -38,24 +38,24 @@ class dataHandlerStringIS : public dataH
 public:
 	// Overwritten to use getSignedLong()
 	///////////////////////////////////////////////////////////
-	virtual double getDouble();
+	virtual double getDouble() const;
 	// Overwritten to use setSignedLong()
 	///////////////////////////////////////////////////////////
-	virtual void setDouble(double value);
+	virtual void setDouble(const double value);
 	// Get the padding byte
 	///////////////////////////////////////////////////////////
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
 	// Get the element size
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringLO.h:

@@ -39,14 +39,14 @@ namespace handlers
 class dataHandlerStringLO : public dataHandlerStringUnicode
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringLT.h:

@@ -39,18 +39,18 @@ namespace handlers
 class dataHandlerStringLT : public dataHandlerStringUnicode
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
-	// TRUE if \ is used as a separator
+	// Separator
 	///////////////////////////////////////////////////////////
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringPN.h:

@@ -69,18 +69,18 @@ myDataSet->setUnicodeString(L"<-"); // :
 class dataHandlerStringPN : public dataHandlerStringUnicode
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 	// Returns the separator =
 	///////////////////////////////////////////////////////////
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringSH.h:

@@ -39,14 +39,14 @@ namespace handlers
 class dataHandlerStringSH : public dataHandlerStringUnicode
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };

Up to file-list project_files/imebra/include/dataHandlerStringST.h:

@@ -39,18 +39,18 @@ namespace handlers
 class dataHandlerStringST : public dataHandlerStringUnicode
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 	// Returns the separator
 	///////////////////////////////////////////////////////////
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringUI.h:

@@ -39,18 +39,18 @@ namespace handlers
 class dataHandlerStringUI : public dataHandlerString
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 	// Returns the separator
 	///////////////////////////////////////////////////////////
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringUT.h:

@@ -39,18 +39,18 @@ namespace handlers
 class dataHandlerStringUT : public dataHandlerStringUnicode
+{
 public:
-	virtual imbxUint8 getPaddingByte();
+	virtual imbxUint8 getPaddingByte() const;
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 protected:
 	// Return the maximum string's length
 	///////////////////////////////////////////////////////////
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 	// TRUE if \ is used as a separator
 	///////////////////////////////////////////////////////////
-	virtual wchar_t getSeparator();
+	virtual wchar_t getSeparator() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerStringUnicode.h:

@@ -68,33 +68,33 @@ public:
 	///                      dicom charsets used in the string
 	///
 	///////////////////////////////////////////////////////////
-	virtual void getCharsetsList(charsetsList::tCharsetsList* pCharsetsList);
+	virtual void getCharsetsList(charsetsList::tCharsetsList* pCharsetsList) const;
 protected:
 	// Convert a string to unicode, using the dicom charsets
 	///////////////////////////////////////////////////////////
-	virtual std::wstring convertToUnicode(std::string value);
+	virtual std::wstring convertToUnicode(const std::string& value) const;
 	// Convert a string from unicode, using the dicom charsets
 	///////////////////////////////////////////////////////////
-	virtual std::string convertFromUnicode(std::wstring value);
+	virtual std::string convertFromUnicode(const std::wstring& value, charsetsList::tCharsetsList* pCharsetsList) const;
 	charsetConversion m_charsetConversion;
 	charsetConversion m_localeCharsetConversion;
-	dicomCharsetInformation* getCharsetInfo(std::wstring dicomName);
+	dicomCharsetInformation* getCharsetInfo(const std::wstring& dicomName) const;
 };
 class dataHandlerStringUnicodeException: public std::runtime_error
+{
 public:
-	dataHandlerStringUnicodeException(std::string message): std::runtime_error(message){}
+	dataHandlerStringUnicodeException(const std::string& message): std::runtime_error(message){}
 };
 class dataHandlerStringUnicodeExceptionUnknownCharset: public dataHandlerStringUnicodeException
+{
 public:
-	dataHandlerStringUnicodeExceptionUnknownCharset(std::string message): dataHandlerStringUnicodeException(message){}
+	dataHandlerStringUnicodeExceptionUnknownCharset(const std::string& message): dataHandlerStringUnicodeException(message){}
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/dataHandlerTime.h:

@@ -39,7 +39,7 @@ class dataHandlerTime : public dataHandl
+{
 public:
-	virtual imbxUint32 getUnitSize();
+	virtual imbxUint32 getUnitSize() const;
 	virtual void getDate(
 		imbxInt32* pYear,
@@ -50,7 +50,7 @@ public:
 		imbxInt32* pSeconds,
 		imbxInt32* pNanoseconds,
 		imbxInt32* pOffsetHours,
-		imbxInt32* pOffsetMinutes);
+		imbxInt32* pOffsetMinutes) const;
 	virtual void setDate(
 		imbxInt32 year,
@@ -77,7 +77,7 @@ public:
 	///          buffer
 	///
 	///////////////////////////////////////////////////////////
-	virtual std::wstring getUnicodeString();
+	virtual std::wstring getUnicodeString() const;
 	/// \brief Set the date from a string.
 	///
@@ -91,12 +91,12 @@ public:
 	/// @param value the string representing the time to be set
 	///
 	///////////////////////////////////////////////////////////
-	virtual void setUnicodeString(std::wstring value);
+	virtual void setUnicodeString(const std::wstring& value);
-	void parseBuffer(ptr<memory> memoryBuffer);
+	void parseBuffer(const ptr<memory>& memoryBuffer);
 protected:
-	virtual imbxUint32 maxSize();
+	virtual imbxUint32 maxSize() const;
 };
 } // namespace handlers

Up to file-list project_files/imebra/include/image.h:

@@ -36,7 +36,7 @@ namespace handlers
 	///  subsampled.
 	///
 	/// The application never needs to resize the data managed
-	///  by this handler because the object image does this.
+	///  by this handler because the image object does this.
 	///
 	///////////////////////////////////////////////////////////
 	typedef dataHandlerNumeric<imbxInt32> imageHandler;
@@ -87,12 +87,12 @@ public:
 	image():
 		baseObject(ptr<baseObject>(new baseObject) ),
 			m_rowLength(0),
 			m_channelPixelSize(0),
 			m_channelsNumber(0),
 			m_imageDepth(depthUnknown),
 			m_highBit(0),
 			m_sizeX(0),
 			m_sizeY(0),
 			m_channelPixelSize(0),
 			m_channelsNumber(0),
 			m_imageDepth(depthUnknown),
 			m_highBit(0),
 			m_sizeX(0),
 			m_sizeY(0),
 			m_sizeMmX(0),
 			m_sizeMmY(0){}

Up to file-list project_files/imebra/src/buffer.cpp:

@@ -62,7 +62,7 @@ namespace imebra
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-buffer::buffer(ptr<baseObject> externalLock, std::string defaultType /* ="" */):
+buffer::buffer(const ptr<baseObject>& externalLock, const std::string& defaultType /* ="" */):
 	baseObject(externalLock),
 		m_originalBufferPosition(0),
 		m_originalBufferLength(0),
@@ -94,9 +94,9 @@ buffer::buffer(ptr<baseObject> externalL
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
 buffer::buffer(ptr<baseObject> externalLock,
 		std::string defaultType,
-		ptr<baseStream> originalStream,
+buffer::buffer(const ptr<baseObject>& externalLock,
 		const std::string& defaultType,
 		const ptr<baseStream>& originalStream,
 		imbxUint32 bufferPosition,
 		imbxUint32 bufferLength,
 		imbxUint32 wordLength,

Up to file-list project_files/imebra/src/charsetsList.cpp:

@@ -45,7 +45,7 @@ namespace charsetsList
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void updateCharsets(tCharsetsList* pCharsetsList, tCharsetsList* pDestinationCharsetsList)
+void updateCharsets(const tCharsetsList* pCharsetsList, tCharsetsList* pDestinationCharsetsList)
+{
 	PUNTOEXE_FUNCTION_START(L"charsetsList::updateCharsets");
@@ -59,7 +59,7 @@ void updateCharsets(tCharsetsList* pChar
 	// Copy the charsets in the local list (if they are not
 	//  already there)
 	///////////////////////////////////////////////////////////
-	for(tCharsetsList::iterator scanCharsets = pCharsetsList->begin(); scanCharsets != pCharsetsList->end(); ++scanCharsets)
+	for(tCharsetsList::const_iterator scanCharsets = pCharsetsList->begin(); scanCharsets != pCharsetsList->end(); ++scanCharsets)
+	{
 		bool bExist = false;
 		for(tCharsetsList::iterator scanExistingCharsets = pDestinationCharsetsList->begin(); scanExistingCharsets != pDestinationCharsetsList->end(); ++scanExistingCharsets)
@@ -91,11 +91,11 @@ void updateCharsets(tCharsetsList* pChar
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void copyCharsets(tCharsetsList* pSourceCharsetsList, tCharsetsList* pDestinationCharsetsList)
+void copyCharsets(const tCharsetsList* pSourceCharsetsList, tCharsetsList* pDestinationCharsetsList)
+{
 	PUNTOEXE_FUNCTION_START(L"charsetsList::copyCharsets");
-	for(tCharsetsList::iterator scanCharsets = pSourceCharsetsList->begin(); scanCharsets != pSourceCharsetsList->end(); ++scanCharsets)
+	for(tCharsetsList::const_iterator scanCharsets = pSourceCharsetsList->begin(); scanCharsets != pSourceCharsetsList->end(); ++scanCharsets)
+	{
 		pDestinationCharsetsList->push_back(*scanCharsets);
+	}
@@ -107,4 +107,4 @@ void copyCharsets(tCharsetsList* pSource
 } // namespace imebra
-} // namespace puntoexe
+} // namespace puntoexe

Up to file-list project_files/imebra/src/dataHandler.cpp:

@@ -112,11 +112,11 @@ void dataHandler::abort()
 //
 ///////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////
-void dataHandler::skip(int skip)
+void dataHandler::skip(const int skip)
+{
 	PUNTOEXE_FUNCTION_START(L"dataHandler::skip");
-	while(skip--)
+	for( int skipCount(skip); skipCount != 0; --skipCount)
+	{

…	…	@@ -146,7 +146,7 @@ baseObject::baseObject():m_lockCounter(0
146	146	//
147	147	///////////////////////////////////////////////////////////
148	148	///////////////////////////////////////////////////////////
149		baseObject::baseObject(~~ptr<baseObject>~~ externalLock): m_externalLock(externalLock),
	149	baseObject::baseObject(const ptr<baseObject>& externalLock): m_externalLock(externalLock),
150	150	m_lockCounter(0), m_bValid(true), m_pExceptionsManager(exceptionsManager::getExceptionsManager())
151	151	{
152	152	}