CDT.hpp   CDT.hpp 
skipping to change at line 101 skipping to change at line 101
REFERENCE_VAL = 0x80 */ REFERENCE_VAL = 0x80 */
}; };
/** /**
@enum eMergeStrategy CDT.hpp <CDT.hpp> @enum eMergeStrategy CDT.hpp <CDT.hpp>
@brief Describes merging strategy for HASH-es and ARRAY-s @brief Describes merging strategy for HASH-es and ARRAY-s
*/ */
enum eMergeStrategy { FAST_MERGE, DEEP_MERGE }; enum eMergeStrategy { FAST_MERGE, DEEP_MERGE };
// FWD // FWD
class SortingComparator; class CTPP2DECL SortingComparator;
/** /**
@brief Constructor @brief Constructor
@param oValue - type of value @param oValue - type of value
*/ */
CDT(const CDT::eValType & oValue = UNDEF); CDT(const CDT::eValType & oValue = UNDEF);
/** /**
@brief Copy constructor @brief Copy constructor
@param oCDT - Object to copy @param oCDT - Object to copy
skipping to change at line 1749 skipping to change at line 1749
/** /**
@brief Quick sort ARRAY @brief Quick sort ARRAY
@param oSortingComparator - variables comparator @param oSortingComparator - variables comparator
*/ */
void SortArray(const SortingComparator & oSortingComparator); void SortArray(const SortingComparator & oSortingComparator);
/** /**
@class SortingComparator CDT.hpp <CDT.hpp> @class SortingComparator CDT.hpp <CDT.hpp>
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortingComparator class CTPP2DECL SortingComparator
{ {
public: public:
/** /**
@brief Sorting direction @brief Sorting direction
*/ */
enum eSortingDirection { ASC, DESC }; enum eSortingDirection { ASC, DESC };
/** /**
@brief Compare two values. @brief Compare two values.
@param oX - first value to compare @param oX - first value to compare
skipping to change at line 1772 skipping to change at line 1772
*/ */
virtual bool operator()(const CDT & oX, const CDT & oY) cons t = 0; virtual bool operator()(const CDT & oX, const CDT & oY) cons t = 0;
/** /**
@brief A dertructor @brief A dertructor
*/ */
virtual ~SortingComparator() throw(); virtual ~SortingComparator() throw();
}; };
// FWD // FWD
class ConstIterator; class CTPP2DECL ConstIterator;
/** /**
@class Iterator CDT.hpp <CDT.hpp> @class Iterator CDT.hpp <CDT.hpp>
@brief CDT[HASH] forward iterator @brief CDT[HASH] forward iterator
*/ */
class Iterator class CTPP2DECL Iterator
{ {
private: private:
friend class CDT; friend class CDT;
friend class ConstIterator; friend class ConstIterator;
/** Hash iterator */ /** Hash iterator */
CDT::Map::iterator itMap; CDT::Map::iterator itMap;
/** /**
@brief Constructor @brief Constructor
skipping to change at line 1857 skipping to change at line 1857
@brief Find element in hash @brief Find element in hash
@param sKey - element name @param sKey - element name
@return Iterator pointed to element or to end of hash if nothing f ound @return Iterator pointed to element or to end of hash if nothing f ound
*/ */
Iterator Find(const STLW::string & sKey); Iterator Find(const STLW::string & sKey);
/** /**
@class ConstIterator CDT.hpp <CDT.hpp> @class ConstIterator CDT.hpp <CDT.hpp>
@brief CDT[HASH] forward constant iterator @brief CDT[HASH] forward constant iterator
*/ */
class ConstIterator class CTPP2DECL ConstIterator
{ {
private: private:
friend class CDT; friend class CDT;
/** Hash iterator */ /** Hash iterator */
CDT::Map::const_iterator itMap; CDT::Map::const_iterator itMap;
public: public:
/** /**
@brief Copy constructor @brief Copy constructor
skipping to change at line 1952 skipping to change at line 1952
eValType CastToNumber(INT_64 & iData, eValType CastToNumber(INT_64 & iData,
W_FLOAT & dData) const; W_FLOAT & dData) const;
/** /**
@brief A destructor @brief A destructor
*/ */
~CDT() throw(); ~CDT() throw();
private: private:
// Friends // Friends
friend CDT operator-(const UINT_64 & oValue, const CDT & oCDT); CTPP2DECL friend CDT operator-(const UINT_64 & oValue, const CDT & o
friend CDT operator-(const INT_64 & oValue, const CDT & oCDT); CDT);
friend CDT operator-(const W_FLOAT & oValue, const CDT & oCDT); CTPP2DECL friend CDT operator-(const INT_64 & oValue, const CDT & o
CDT);
friend CDT operator/(const UINT_64 & oValue, const CDT & oCDT); CTPP2DECL friend CDT operator-(const W_FLOAT & oValue, const CDT & o
friend CDT operator/(const INT_64 & oValue, const CDT & oCDT); CDT);
friend CDT operator/(const W_FLOAT & oValue, const CDT & oCDT);
CTPP2DECL friend CDT operator/(const UINT_64 & oValue, const CDT & o
CDT);
CTPP2DECL friend CDT operator/(const INT_64 & oValue, const CDT & o
CDT);
CTPP2DECL friend CDT operator/(const W_FLOAT & oValue, const CDT & o
CDT);
// FWD // FWD
struct _CDT; struct _CDT;
/** Plain Old datatypes */ /** Plain Old datatypes */
union union
{ {
/** Signed interger */ /** Signed interger */
INT_64 i_data; INT_64 i_data;
/** Floating point value */ /** Floating point value */
skipping to change at line 2025 skipping to change at line 2025
// //
// //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////// // //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////
/** /**
@brief Operator + for UINT_64 and CDT arguments @brief Operator + for UINT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of addition with same type of oCDT @return result of addition with same type of oCDT
*/ */
CDT operator+(const UINT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator+(const UINT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator + for INT_64 and CDT arguments @brief Operator + for INT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of addition with same type of oCDT @return result of addition with same type of oCDT
*/ */
CDT operator+(const INT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator+(const INT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator + for UINT_32 and CDT arguments @brief Operator + for UINT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of addition with same type of oCDT @return result of addition with same type of oCDT
*/ */
CDT operator+(const UINT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator+(const UINT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator + for INT_32 and CDT arguments @brief Operator + for INT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of addition with same type of oCDT @return result of addition with same type of oCDT
*/ */
CDT operator+(const INT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator+(const INT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator + for W_FLOAT and CDT arguments @brief Operator + for W_FLOAT and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of addition with same type of oCDT @return result of addition with same type of oCDT
*/ */
CDT operator+(const W_FLOAT & oValue, const CDT & oCDT); CTPP2DECL CDT operator+(const W_FLOAT & oValue, const CDT & oCDT);
// //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////// // //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////
/** /**
@brief Operator - for UINT_64 and CDT arguments @brief Operator - for UINT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of substraction with same type of oCDT @return result of substraction with same type of oCDT
*/ */
CDT operator-(const UINT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator-(const UINT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator - for INT_64 and CDT arguments @brief Operator - for INT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of substraction with same type of oCDT @return result of substraction with same type of oCDT
*/ */
CDT operator-(const INT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator-(const INT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator - for UINT_32 and CDT arguments @brief Operator - for UINT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of substraction with same type of oCDT @return result of substraction with same type of oCDT
*/ */
CDT operator-(const UINT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator-(const UINT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator - for INT_32 and CDT arguments @brief Operator - for INT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of substraction with same type of oCDT @return result of substraction with same type of oCDT
*/ */
CDT operator-(const INT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator-(const INT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator - for W_FLOAT and CDT arguments @brief Operator - for W_FLOAT and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of substraction with same type of oCDT @return result of substraction with same type of oCDT
*/ */
CDT operator-(const W_FLOAT & oValue, const CDT & oCDT); CTPP2DECL CDT operator-(const W_FLOAT & oValue, const CDT & oCDT);
// //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////// // //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////
/** /**
@brief Operator * for UINT_64 and CDT arguments @brief Operator * for UINT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of multiplication with same type of oCDT @return result of multiplication with same type of oCDT
*/ */
CDT operator*(const UINT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator*(const UINT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator * for INT_64 and CDT arguments @brief Operator * for INT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of multiplication with same type of oCDT @return result of multiplication with same type of oCDT
*/ */
CDT operator*(const INT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator*(const INT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator * for UINT_32 and CDT arguments @brief Operator * for UINT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of multiplication with same type of oCDT @return result of multiplication with same type of oCDT
*/ */
CDT operator*(const UINT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator*(const UINT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator * for INT_32 and CDT arguments @brief Operator * for INT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of multiplication with same type of oCDT @return result of multiplication with same type of oCDT
*/ */
CDT operator*(const INT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator*(const INT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator * for W_FLOAT and CDT arguments @brief Operator * for W_FLOAT and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of multiplication with same type of oCDT @return result of multiplication with same type of oCDT
*/ */
CDT operator*(const W_FLOAT & oValue, const CDT & oCDT); CTPP2DECL CDT operator*(const W_FLOAT & oValue, const CDT & oCDT);
// //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////// // //////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////
/** /**
@brief Operator / for UINT_64 and CDT arguments @brief Operator / for UINT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of division with same type of oCDT @return result of division with same type of oCDT
*/ */
CDT operator/(const UINT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator/(const UINT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator / for INT_64 and CDT arguments @brief Operator / for INT_64 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of division with same type of oCDT @return result of division with same type of oCDT
*/ */
CDT operator/(const INT_64 & oValue, const CDT & oCDT); CTPP2DECL CDT operator/(const INT_64 & oValue, const CDT & oCDT);
/** /**
@brief Operator / for UINT_32 and CDT arguments @brief Operator / for UINT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of division with same type of oCDT @return result of division with same type of oCDT
*/ */
CDT operator/(const UINT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator/(const UINT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator / for INT_32 and CDT arguments @brief Operator / for INT_32 and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of division with same type of oCDT @return result of division with same type of oCDT
*/ */
CDT operator/(const INT_32 & oValue, const CDT & oCDT); CTPP2DECL CDT operator/(const INT_32 & oValue, const CDT & oCDT);
/** /**
@brief Operator / for W_FLOAT and CDT arguments @brief Operator / for W_FLOAT and CDT arguments
@param oValue - 1-st argument @param oValue - 1-st argument
@param oCDT - 2-nd argument @param oCDT - 2-nd argument
@return result of division with same type of oCDT @return result of division with same type of oCDT
*/ */
CDT operator/(const W_FLOAT & oValue, const CDT & oCDT); CTPP2DECL CDT operator/(const W_FLOAT & oValue, const CDT & oCDT);
} // namespace CTPP } // namespace CTPP
#endif // _CDT_HPP__ #endif // _CDT_HPP__
// End. // End.
 End of changes. 26 change blocks. 
32 lines changed or deleted 38 lines changed or added


 CDTSortRoutines.hpp   CDTSortRoutines.hpp 
skipping to change at line 49 skipping to change at line 49
#include "CDT.hpp" #include "CDT.hpp"
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
/** /**
@class SortCompareNum CDTSortRoutines.hpp <CDTSortRoutines.hpp> @class SortCompareNum CDTSortRoutines.hpp <CDTSortRoutines.hpp>
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortCompareNum: class CTPP2DECL SortCompareNum:
public CDT::SortingComparator public CDT::SortingComparator
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param eIDirection - sorting direction @param eIDirection - sorting direction
*/ */
SortCompareNum(const CDT::SortingComparator::eSortingDirection & eI Direction = CDT::SortingComparator::ASC); SortCompareNum(const CDT::SortingComparator::eSortingDirection & eI Direction = CDT::SortingComparator::ASC);
/** /**
skipping to change at line 80 skipping to change at line 80
~SortCompareNum() throw(); ~SortCompareNum() throw();
private: private:
/** Sorting direction */ /** Sorting direction */
const CDT::SortingComparator::eSortingDirection eDirection; const CDT::SortingComparator::eSortingDirection eDirection;
}; };
/** /**
@class SortCompareStr CDTSortRoutines.hpp <CDTSortRoutines.hpp> @class SortCompareStr CDTSortRoutines.hpp <CDTSortRoutines.hpp>
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortCompareStr: class CTPP2DECL SortCompareStr:
public CDT::SortingComparator public CDT::SortingComparator
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param eIDirection - sorting direction @param eIDirection - sorting direction
*/ */
SortCompareStr(const CDT::SortingComparator::eSortingDirection & eI Direction = CDT::SortingComparator::ASC); SortCompareStr(const CDT::SortingComparator::eSortingDirection & eI Direction = CDT::SortingComparator::ASC);
/** /**
skipping to change at line 111 skipping to change at line 111
~SortCompareStr() throw(); ~SortCompareStr() throw();
private: private:
/** Sorting direction */ /** Sorting direction */
const CDT::SortingComparator::eSortingDirection eDirection; const CDT::SortingComparator::eSortingDirection eDirection;
}; };
/** /**
@class SortCompareNumHashElement CDTSortRoutines.hpp <CDTSortRoutines.hpp > @class SortCompareNumHashElement CDTSortRoutines.hpp <CDTSortRoutines.hpp >
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortCompareNumHashElement: class CTPP2DECL SortCompareNumHashElement:
public CDT::SortingComparator public CDT::SortingComparator
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param sIKey - key of key => value pair of HASH to compare @param sIKey - key of key => value pair of HASH to compare
@param eIDirection - sorting direction @param eIDirection - sorting direction
*/ */
SortCompareNumHashElement(const STLW::string & sIKey, SortCompareNumHashElement(const STLW::string & sIKey,
const CDT::SortingComparator::eSortingDire ction & eIDirection = CDT::SortingComparator::ASC); const CDT::SortingComparator::eSortingDire ction & eIDirection = CDT::SortingComparator::ASC);
skipping to change at line 147 skipping to change at line 147
/** Array element index */ /** Array element index */
const STLW::string sKey; const STLW::string sKey;
/** Sorting direction */ /** Sorting direction */
const CDT::SortingComparator::eSortingDirection eDirection; const CDT::SortingComparator::eSortingDirection eDirection;
}; };
/** /**
@class SortCompareStrHashElement CDTSortRoutines.hpp <CDTSortRoutines.hpp > @class SortCompareStrHashElement CDTSortRoutines.hpp <CDTSortRoutines.hpp >
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortCompareStrHashElement: class CTPP2DECL SortCompareStrHashElement:
public CDT::SortingComparator public CDT::SortingComparator
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param sIKey - key of key => value pair of HASH to compare @param sIKey - key of key => value pair of HASH to compare
@param eIDirection - sorting direction @param eIDirection - sorting direction
*/ */
SortCompareStrHashElement(const STLW::string & sIKey, SortCompareStrHashElement(const STLW::string & sIKey,
const CDT::SortingComparator::eSortingDire ction & eIDirection = CDT::SortingComparator::ASC); const CDT::SortingComparator::eSortingDire ction & eIDirection = CDT::SortingComparator::ASC);
skipping to change at line 183 skipping to change at line 183
/** Array element index */ /** Array element index */
const STLW::string sKey; const STLW::string sKey;
/** Sorting direction */ /** Sorting direction */
const CDT::SortingComparator::eSortingDirection eDirection; const CDT::SortingComparator::eSortingDirection eDirection;
}; };
/** /**
@class SortCompareNumArrayElement CDTSortRoutines.hpp <CDTSortRoutines.hp p> @class SortCompareNumArrayElement CDTSortRoutines.hpp <CDTSortRoutines.hp p>
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortCompareNumArrayElement: class CTPP2DECL SortCompareNumArrayElement:
public CDT::SortingComparator public CDT::SortingComparator
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param iIIndex - index of ARRAY to compare @param iIIndex - index of ARRAY to compare
@param eIDirection - sorting direction @param eIDirection - sorting direction
*/ */
SortCompareNumArrayElement(const UINT_32 iIIndex, SortCompareNumArrayElement(const UINT_32 iIIndex,
const CDT::SortingComparator::eSortingDir ection & eIDirection = CDT::SortingComparator::ASC); const CDT::SortingComparator::eSortingDir ection & eIDirection = CDT::SortingComparator::ASC);
skipping to change at line 218 skipping to change at line 218
/** Array element index */ /** Array element index */
const UINT_32 iIndex; const UINT_32 iIndex;
/** Sorting direction */ /** Sorting direction */
const CDT::SortingComparator::eSortingDirection eDirection; const CDT::SortingComparator::eSortingDirection eDirection;
}; };
/** /**
@class SortCompareNumArrayElement CDTSortRoutines.hpp <CDTSortRoutines.hp p> @class SortCompareNumArrayElement CDTSortRoutines.hpp <CDTSortRoutines.hp p>
@brief Sorting comparator @brief Sorting comparator
*/ */
class SortCompareStrArrayElement: class CTPP2DECL SortCompareStrArrayElement:
public CDT::SortingComparator public CDT::SortingComparator
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param iIIndex - index of ARRAY to compare @param iIIndex - index of ARRAY to compare
@param eIDirection - sorting direction @param eIDirection - sorting direction
*/ */
SortCompareStrArrayElement(const UINT_32 iIIndex, SortCompareStrArrayElement(const UINT_32 iIIndex,
const CDT::SortingComparator::eSortingDir ection & eIDirection = CDT::SortingComparator::ASC); const CDT::SortingComparator::eSortingDir ection & eIDirection = CDT::SortingComparator::ASC);
 End of changes. 6 change blocks. 
6 lines changed or deleted 6 lines changed or added


 CTPP2FileLogger.hpp   CTPP2FileLogger.hpp 
skipping to change at line 51 skipping to change at line 51
@brief CTPP2 file logger @brief CTPP2 file logger
*/ */
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
/** /**
@class FileLogger CTPP2FileLogger.hpp <CTPP2FileLogger.hpp> @class FileLogger CTPP2FileLogger.hpp <CTPP2FileLogger.hpp>
@brief CTPP2 logger subsystem @brief CTPP2 logger subsystem
*/ */
class FileLogger: class CTPP2DECL FileLogger:
public Logger public Logger
{ {
protected: protected:
/** File handle */ /** File handle */
FILE * F; FILE * F;
public: public:
/** /**
@brief Constructor @brief Constructor
@param iIBasePriority - base priority @param iIBasePriority - base priority
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 CTPP2Logger.hpp   CTPP2Logger.hpp 
skipping to change at line 67 skipping to change at line 67
#define C_START_MESSAGE_LEN 2048 #define C_START_MESSAGE_LEN 2048
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
/** /**
@class Logger CTPP2Logger.hpp <CTPP2Logger.hpp> @class Logger CTPP2Logger.hpp <CTPP2Logger.hpp>
@brief CTPP2 logger subsystem @brief CTPP2 logger subsystem
*/ */
class Logger class CTPP2DECL Logger
{ {
protected: protected:
/** Base priority */ /** Base priority */
UINT_32 iBasePriority; UINT_32 iBasePriority;
public: public:
/** /**
@brief Constructor @brief Constructor
@param iIBasePriority - base priority @param iIBasePriority - base priority
*/ */
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 CTPP2Sprintf.hpp   CTPP2Sprintf.hpp 
skipping to change at line 47 skipping to change at line 47
@brief CTPP sprintf implementation @brief CTPP sprintf implementation
*/ */
#include "CDT.hpp" #include "CDT.hpp"
#define C_STRING_BUFFER_LEN 1024 #define C_STRING_BUFFER_LEN 1024
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
INT_32 FormatString(const STLW::string & sFormatString, STLW::string & sRes ult, const CDT & oArgs); CTPP2DECL INT_32 FormatString(const STLW::string & sFormatString, STLW::str ing & sResult, const CDT & oArgs);
} // namespace CTPP } // namespace CTPP
#endif // _CTPP2_SPRINTF_HPP__ #endif // _CTPP2_SPRINTF_HPP__
// End. // End.
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 CTPP2StreamOutputCollector.hpp   CTPP2StreamOutputCollector.hpp 
skipping to change at line 50 skipping to change at line 50
@brief Virtual machine C++ stream output data collector @brief Virtual machine C++ stream output data collector
*/ */
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
/** /**
@class StreamOutputCollector StreamOutputCollector.hpp <StreamOutputColle ctor.hpp> @class StreamOutputCollector StreamOutputCollector.hpp <StreamOutputColle ctor.hpp>
@brief Output data collector (C++ data stream) @brief Output data collector (C++ data stream)
*/ */
class StreamOutputCollector: class CTPP2DECL StreamOutputCollector:
public OutputCollector public OutputCollector
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param oIOutputStream - output data stream @param oIOutputStream - output data stream
*/ */
StreamOutputCollector(STLW::ostream & oIOutputStream); StreamOutputCollector(STLW::ostream & oIOutputStream);
/** /**
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 CTPP2StringOutputCollector.hpp   CTPP2StringOutputCollector.hpp 
skipping to change at line 50 skipping to change at line 50
@brief Virtual machine file output data collector @brief Virtual machine file output data collector
*/ */
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
/** /**
@class StringOutputCollector CTPP2StringOutputCollector.hpp <CTPP2StringO utputCollector.hpp> @class StringOutputCollector CTPP2StringOutputCollector.hpp <CTPP2StringO utputCollector.hpp>
@brief Output data collector @brief Output data collector
*/ */
class StringOutputCollector: class CTPP2DECL StringOutputCollector:
public OutputCollector public OutputCollector
{ {
public: public:
/** /**
@brief Constructor @brief Constructor
@param sIResult - Data object @param sIResult - Data object
*/ */
StringOutputCollector(STLW::string & sIResult); StringOutputCollector(STLW::string & sIResult);
/** /**
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 CTPP2SysHeaders.h   CTPP2SysHeaders.h 
skipping to change at line 81 skipping to change at line 81
#define CTPP_ESCAPE_BUFFER_LEN 1024 #define CTPP_ESCAPE_BUFFER_LEN 1024
#define CTPP_MAX_TEMPLATE_RECURSION_DEPTH 1024 #define CTPP_MAX_TEMPLATE_RECURSION_DEPTH 1024
#define ICONV_SUPPORT 1 #define ICONV_SUPPORT 1
#define ICONV_DISCARD_ILSEQ 1 #define ICONV_DISCARD_ILSEQ 1
#define ICONV_TRANSLITERATE 1 #define ICONV_TRANSLITERATE 1
#define CTPP_VERSION "2.8.2" #define CTPP_VERSION "2.8.3"
#define CTPP_IDENT "Dzoraget" #define CTPP_IDENT "Dzoraget"
#define CTPP_MASTER_SITE_URL "http://ctpp.havoc.ru/" #define CTPP_MASTER_SITE_URL "http://ctpp.havoc.ru/"
/* #undef THROW_EXCEPTION_IN_COMPARATORS */ /* #undef THROW_EXCEPTION_IN_COMPARATORS */
#endif /* _CTPP2_SYS_HEADERS_H__ */ #endif /* _CTPP2_SYS_HEADERS_H__ */
/* End. */ /* End. */
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 CTPP2Util.hpp   CTPP2Util.hpp 
skipping to change at line 50 skipping to change at line 50
namespace CTPP // C++ Template Engine namespace CTPP // C++ Template Engine
{ {
// FWD // FWD
class CDT; class CDT;
/** /**
@class DumpBuffer CTPP2Util.hpp <CTPP2Util.hpp> @class DumpBuffer CTPP2Util.hpp <CTPP2Util.hpp>
@brief Buffer for dumping CDTs. Used as an alternative for std::string (a s string's append is quite slow) @brief Buffer for dumping CDTs. Used as an alternative for std::string (a s string's append is quite slow)
*/ */
class DumpBuffer { class CTPP2DECL DumpBuffer {
public: public:
/** /**
@var typedef UINT_32 StreamSize @var typedef UINT_32 StreamSize
@brief internal size_t analog @brief internal size_t analog
*/ */
typedef UINT_32 StreamSize; typedef UINT_32 StreamSize;
/** /**
@brief Constructor @brief Constructor
*/ */
skipping to change at line 107 skipping to change at line 107
StreamSize iCapacity; StreamSize iCapacity;
}; };
/** /**
@fn UINT_32 crc32(UCCHAR_P sBuffer, const UINT_32 & iSize) @fn UINT_32 crc32(UCCHAR_P sBuffer, const UINT_32 & iSize)
@brief Calculate crc32 checksum @brief Calculate crc32 checksum
@param sBuffer - buffer with source data to calculate CRC @param sBuffer - buffer with source data to calculate CRC
@param iSize - buffer size @param iSize - buffer size
@return CRC32 checksum @return CRC32 checksum
*/ */
UINT_32 crc32(UCCHAR_P sBuffer, const UINT_32 & iSize); CTPP2DECL UINT_32 crc32(UCCHAR_P sBuffer, const UINT_32 & iSize);
/** /**
@fn UINT_32 Swap32(const UINT_32 & iValue) @fn UINT_32 Swap32(const UINT_32 & iValue)
@brief Swap bytes for UINT_32 value @brief Swap bytes for UINT_32 value
@param iValue - value to swap @param iValue - value to swap
@return Swapped value @return Swapped value
*/ */
UINT_32 Swap32(const UINT_32 & iValue); CTPP2DECL UINT_32 Swap32(const UINT_32 & iValue);
/** /**
@fn UINT_64 Swap64(const UINT_64 & iValue) @fn UINT_64 Swap64(const UINT_64 & iValue)
@brief Swap bytes for UINT_64 value @brief Swap bytes for UINT_64 value
@param iValue - value to swap @param iValue - value to swap
@return Swapped value @return Swapped value
*/ */
UINT_64 Swap64(const UINT_64 & iValue); CTPP2DECL UINT_64 Swap64(const UINT_64 & iValue);
/** /**
@fn STLW::string URIEscape(const STLW::string & sData) @fn STLW::string URIEscape(const STLW::string & sData)
@brief Escape value (URI rules) @brief Escape value (URI rules)
@param sData - value to escape @param sData - value to escape
@return Escaped value @return Escaped value
*/ */
STLW::string URIEscape(const STLW::string & sData); CTPP2DECL STLW::string URIEscape(const STLW::string & sData);
/** /**
@fn STLW::string URLEscape(const STLW::string & sData) @fn STLW::string URLEscape(const STLW::string & sData)
@brief Escape value (URL rules) @brief Escape value (URL rules)
@param sData - value to escape @param sData - value to escape
@return Escaped value @return Escaped value
*/ */
STLW::string URLEscape(const STLW::string & sData); CTPP2DECL STLW::string URLEscape(const STLW::string & sData);
/** /**
@fn STLW::string HTMLEscape(const STLW::string & sData) @fn STLW::string HTMLEscape(const STLW::string & sData)
@brief Escape value (HTML rules) @brief Escape value (HTML rules)
@param sData - value to escape @param sData - value to escape
@return Escaped value @return Escaped value
*/ */
STLW::string HTMLEscape(const STLW::string & sData); CTPP2DECL STLW::string HTMLEscape(const STLW::string & sData);
/** /**
@fn STLW::string XMLEscape(const STLW::string & sData) @fn STLW::string XMLEscape(const STLW::string & sData)
@brief Escape value (XML rules) @brief Escape value (XML rules)
@param sData - value to escape @param sData - value to escape
@return Escaped value @return Escaped value
*/ */
STLW::string XMLEscape(const STLW::string & sData); CTPP2DECL STLW::string XMLEscape(const STLW::string & sData);
/** /**
@fn STLW::string WMLEscape(const STLW::string & sData) @fn STLW::string WMLEscape(const STLW::string & sData)
@brief Escape value (WML rules) @brief Escape value (WML rules)
@param sData - value to escape @param sData - value to escape
@return Escaped value @return Escaped value
*/ */
STLW::string WMLEscape(const STLW::string & sData); CTPP2DECL STLW::string WMLEscape(const STLW::string & sData);
/** /**
@fn void CDT2JSON(const CTPP::CDT & oCDT, STLW::string & sData) @fn void CDT2JSON(const CTPP::CDT & oCDT, STLW::string & sData)
@brief Dump CDT to JSON @brief Dump CDT to JSON
@param oCDT - input data @param oCDT - input data
@param sData - output string @param sData - output string
*/ */
void CDT2JSON(const CDT & oCDT, STLW::string & sData); CTPP2DECL void CDT2JSON(const CDT & oCDT, STLW::string & sData);
/** /**
@fn void DumpCDT2JSON(const CTPP::CDT & oCDT, DumpBuffer & oBuffer) @fn void DumpCDT2JSON(const CTPP::CDT & oCDT, DumpBuffer & oBuffer)
@brief Dump CDT to JSON @brief Dump CDT to JSON
@param oCDT - input data @param oCDT - input data
@param oBuffer - buffer to dump CDT to @param oBuffer - buffer to dump CDT to
@return reference to oBuffer @return reference to oBuffer
*/ */
DumpBuffer & DumpCDT2JSON(const CTPP::CDT & oCDT, DumpBuffer & oBuffer); CTPP2DECL DumpBuffer & DumpCDT2JSON(const CTPP::CDT & oCDT, DumpBuffer & oB uffer);
/** /**
@brief Escape string, if need @brief Escape string, if need
@param sSource - input data @param sSource - input data
@param bECMAConventions - use ECMA-262 conventions for escape sequences @param bECMAConventions - use ECMA-262 conventions for escape sequences
@return Escaped string @return Escaped string
*/ */
STLW::string EscapeJSONString(const STLW::string & sSource, CTPP2DECL STLW::string EscapeJSONString(const STLW::string & sSource,
const bool & bECMAConventions = true const bool & bECMAConventi
, ons = true,
const bool & bHTMLSafe = true); const bool & bHTMLSafe = t
rue);
/** /**
@brief Escape and dump string to buffer @brief Escape and dump string to buffer
@param oBuffer - buffer to dump string to @param oBuffer - buffer to dump string to
@param sSource - input data @param sSource - input data
@param bECMAConventions - use ECMA-262 conventions for escape sequences @param bECMAConventions - use ECMA-262 conventions for escape sequences
@return reference to oBuffer @return reference to oBuffer
*/ */
DumpBuffer & DumpJSONString(DumpBuffer& oBuffer, CTPP2DECL DumpBuffer & DumpJSONString(DumpBuffer& oBuffer,
const STLW::string & sSource, const STLW::string & sSource,
const bool & bECMAConventions = true, const bool & bECMAConventions = true,
const bool & bHTMLSafe = true); const bool & bHTMLSafe = true);
/** /**
@fn STLW::string Base64Encode(const STLW::string & sData); @fn STLW::string Base64Encode(const STLW::string & sData);
@brief Encode value in BASE64 encoding @brief Encode value in BASE64 encoding
@param sData - value to encode @param sData - value to encode
@return Encoded value @return Encoded value
*/ */
STLW::string Base64Encode(const STLW::string & sData); CTPP2DECL STLW::string Base64Encode(const STLW::string & sData);
/** /**
@fn STLW::string Base64Decode(const STLW::string & sData); @fn STLW::string Base64Decode(const STLW::string & sData);
@brief Decode value from BASE64 encoding @brief Decode value from BASE64 encoding
@param sData - value to decode @param sData - value to decode
@return Decoded value @return Decoded value
*/ */
STLW::string Base64Decode(const STLW::string & sData); CTPP2DECL STLW::string Base64Decode(const STLW::string & sData);
/** /**
@fn INT_32 utf_charlen(CCHAR_P szString, CCHAR_P szStringEnd); @fn INT_32 utf_charlen(CCHAR_P szString, CCHAR_P szStringEnd);
@brief Length of UTF character @brief Length of UTF character
@brief szString - source string @brief szString - source string
@brief szStringEnd - pointer to the end of string @brief szStringEnd - pointer to the end of string
@return >0 - character length, @return >0 - character length,
-1 - error in multibyte sequence, -1 - error in multibyte sequence,
-2 - is not an UTF8 character, -2 - is not an UTF8 character,
-3 - unexpected end of string reached -3 - unexpected end of string reached
*/ */
INT_32 utf_charlen(CCHAR_P szString, CCHAR_P szStringEnd); CTPP2DECL INT_32 utf_charlen(CCHAR_P szString, CCHAR_P szStringEnd);
/** /**
@fn INT_32 UnicodeToUTF8(UINT_32 iUCS, char * sUTF8) @fn INT_32 UnicodeToUTF8(UINT_32 iUCS, char * sUTF8)
@brief Convert Unicode character to UTF8 @brief Convert Unicode character to UTF8
@param iUCS - Unicode symbol @param iUCS - Unicode symbol
@param sUTF8 - Pointer to buffer, at least 6 octets @param sUTF8 - Pointer to buffer, at least 6 octets
@return UTF8 character length @return UTF8 character length
*/ */
INT_32 UnicodeToUTF8(UINT_32 iUCS, UCHAR_P sUTF8); CTPP2DECL INT_32 UnicodeToUTF8(UINT_32 iUCS, UCHAR_P sUTF8);
} // namespace CTPP } // namespace CTPP
// End. // End.
 End of changes. 17 change blocks. 
23 lines changed or deleted 24 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/