Visual studio compatibility

This removes some inlines when using visual studio to compile, uisng TPT_NO_INLINE. It also fixes many other problems visual studio has with the code

4 files changed, 116 insertions, 110 deletions

diff --git a/src/cajun/elements.cpp b/src/cajun/elements.cpp
index a913f8a..83602f1 100644
--- a/src/cajun/elements.cpp
+++ b/src/cajun/elements.cpp
@@ -44,7 +44,7 @@ namespace json
 {
 
 
-inline Exception::Exception(const std::string& sMessage) :
+TPT_NO_INLINE Exception::Exception(const std::string& sMessage) :
    std::runtime_error(sMessage) {}
 
 
@@ -129,32 +129,32 @@ public:
 
 
 
-inline UnknownElement::UnknownElement() :                               m_pImp( new Imp_T<Null>( Null() ) ) {}
-inline UnknownElement::UnknownElement(const UnknownElement& unknown) :  m_pImp( unknown.m_pImp->Clone()) {}
-inline UnknownElement::UnknownElement(const Object& object) :           m_pImp( new Imp_T<Object>(object) ) {}
-inline UnknownElement::UnknownElement(const Array& array) :             m_pImp( new Imp_T<Array>(array) ) {}
-inline UnknownElement::UnknownElement(const Number& number) :           m_pImp( new Imp_T<Number>(number) ) {}
-inline UnknownElement::UnknownElement(const Boolean& boolean) :         m_pImp( new Imp_T<Boolean>(boolean) ) {}
-inline UnknownElement::UnknownElement(const String& string) :           m_pImp( new Imp_T<String>(string) ) {}
-inline UnknownElement::UnknownElement(const Null& null) :               m_pImp( new Imp_T<Null>(null) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement() :                               m_pImp( new Imp_T<Null>( Null() ) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const UnknownElement& unknown) :  m_pImp( unknown.m_pImp->Clone()) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const Object& object) :           m_pImp( new Imp_T<Object>(object) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const Array& array) :             m_pImp( new Imp_T<Array>(array) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const Number& number) :           m_pImp( new Imp_T<Number>(number) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const Boolean& boolean) :         m_pImp( new Imp_T<Boolean>(boolean) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const String& string) :           m_pImp( new Imp_T<String>(string) ) {}
+TPT_NO_INLINE UnknownElement::UnknownElement(const Null& null) :               m_pImp( new Imp_T<Null>(null) ) {}
 
-inline UnknownElement::~UnknownElement()   { delete m_pImp; }
+TPT_NO_INLINE UnknownElement::~UnknownElement()   { delete m_pImp; }
 
-inline UnknownElement::operator const Object& () const    { return CastTo<Object>(); }
-inline UnknownElement::operator const Array& () const     { return CastTo<Array>(); }
-inline UnknownElement::operator const Number& () const    { return CastTo<Number>(); }
-inline UnknownElement::operator const Boolean& () const   { return CastTo<Boolean>(); }
-inline UnknownElement::operator const String& () const    { return CastTo<String>(); }
-inline UnknownElement::operator const Null& () const      { return CastTo<Null>(); }
+TPT_NO_INLINE UnknownElement::operator const Object& () const    { return CastTo<Object>(); }
+TPT_NO_INLINE UnknownElement::operator const Array& () const     { return CastTo<Array>(); }
+TPT_NO_INLINE UnknownElement::operator const Number& () const    { return CastTo<Number>(); }
+TPT_NO_INLINE UnknownElement::operator const Boolean& () const   { return CastTo<Boolean>(); }
+TPT_NO_INLINE UnknownElement::operator const String& () const    { return CastTo<String>(); }
+TPT_NO_INLINE UnknownElement::operator const Null& () const      { return CastTo<Null>(); }
 
-inline UnknownElement::operator Object& ()    { return ConvertTo<Object>(); }
-inline UnknownElement::operator Array& ()     { return ConvertTo<Array>(); }
-inline UnknownElement::operator Number& ()    { return ConvertTo<Number>(); }
-inline UnknownElement::operator Boolean& ()   { return ConvertTo<Boolean>(); }
-inline UnknownElement::operator String& ()    { return ConvertTo<String>(); }
-inline UnknownElement::operator Null& ()      { return ConvertTo<Null>(); }
+TPT_NO_INLINE UnknownElement::operator Object& ()    { return ConvertTo<Object>(); }
+TPT_NO_INLINE UnknownElement::operator Array& ()     { return ConvertTo<Array>(); }
+TPT_NO_INLINE UnknownElement::operator Number& ()    { return ConvertTo<Number>(); }
+TPT_NO_INLINE UnknownElement::operator Boolean& ()   { return ConvertTo<Boolean>(); }
+TPT_NO_INLINE UnknownElement::operator String& ()    { return ConvertTo<String>(); }
+TPT_NO_INLINE UnknownElement::operator Null& ()      { return ConvertTo<Null>(); }
 
-inline UnknownElement& UnknownElement::operator = (const UnknownElement& unknown) 
+TPT_NO_INLINE UnknownElement& UnknownElement::operator = (const UnknownElement& unknown) 
 {
    // always check for this
    if (&unknown != this)
@@ -170,28 +170,28 @@ inline UnknownElement& UnknownElement::operator = (const UnknownElement& unknown
    return *this;
 }
 
-inline UnknownElement& UnknownElement::operator[] (const std::string& key)
+TPT_NO_INLINE UnknownElement& UnknownElement::operator[] (const std::string& key)
 {
    // the people want an object. make us one if we aren't already
    Object& object = ConvertTo<Object>();
    return object[key];
 }
 
-inline const UnknownElement& UnknownElement::operator[] (const std::string& key) const
+TPT_NO_INLINE const UnknownElement& UnknownElement::operator[] (const std::string& key) const
 {
    // throws if we aren't an object
    const Object& object = CastTo<Object>();
    return object[key];
 }
 
-inline UnknownElement& UnknownElement::operator[] (size_t index)
+TPT_NO_INLINE UnknownElement& UnknownElement::operator[] (size_t index)
 {
    // the people want an array. make us one if we aren't already
    Array& array = ConvertTo<Array>();
    return array[index];
 }
 
-inline const UnknownElement& UnknownElement::operator[] (size_t index) const
+TPT_NO_INLINE const UnknownElement& UnknownElement::operator[] (size_t index) const
 {
    // throws if we aren't an array
    const Array& array = CastTo<Array>();
@@ -227,11 +227,11 @@ ElementTypeT& UnknownElement::ConvertTo()
 }
 
 
-inline void UnknownElement::Accept(ConstVisitor& visitor) const { m_pImp->Accept(visitor); }
-inline void UnknownElement::Accept(Visitor& visitor)            { m_pImp->Accept(visitor); }
+TPT_NO_INLINE void UnknownElement::Accept(ConstVisitor& visitor) const { m_pImp->Accept(visitor); }
+TPT_NO_INLINE void UnknownElement::Accept(Visitor& visitor)            { m_pImp->Accept(visitor); }
 
 
-inline bool UnknownElement::operator == (const UnknownElement& element) const
+TPT_NO_INLINE bool UnknownElement::operator == (const UnknownElement& element) const
 {
    return m_pImp->Compare(*element.m_pImp);
 }
@@ -242,10 +242,10 @@ inline bool UnknownElement::operator == (const UnknownElement& element) const
 // Object members
 
 
-inline Object::Member::Member(const std::string& nameIn, const UnknownElement& elementIn) :
+TPT_NO_INLINE Object::Member::Member(const std::string& nameIn, const UnknownElement& elementIn) :
    name(nameIn), element(elementIn) {}
 
-inline bool Object::Member::operator == (const Member& member) const 
+TPT_NO_INLINE bool Object::Member::operator == (const Member& member) const 
 {
    return name == member.name &&
           element == member.element;
@@ -265,30 +265,30 @@ private:
 
 
 
-inline Object::iterator Object::Begin() { return m_Members.begin(); }
-inline Object::iterator Object::End() { return m_Members.end(); }
-inline Object::const_iterator Object::Begin() const { return m_Members.begin(); }
-inline Object::const_iterator Object::End() const { return m_Members.end(); }
+TPT_NO_INLINE Object::iterator Object::Begin() { return m_Members.begin(); }
+TPT_NO_INLINE Object::iterator Object::End() { return m_Members.end(); }
+TPT_NO_INLINE Object::const_iterator Object::Begin() const { return m_Members.begin(); }
+TPT_NO_INLINE Object::const_iterator Object::End() const { return m_Members.end(); }
 
-inline size_t Object::Size() const { return m_Members.size(); }
-inline bool Object::Empty() const { return m_Members.empty(); }
+TPT_NO_INLINE size_t Object::Size() const { return m_Members.size(); }
+TPT_NO_INLINE bool Object::Empty() const { return m_Members.empty(); }
 
-inline Object::iterator Object::Find(const std::string& name) 
+TPT_NO_INLINE Object::iterator Object::Find(const std::string& name) 
 {
    return std::find_if(m_Members.begin(), m_Members.end(), Finder(name));
 }
 
-inline Object::const_iterator Object::Find(const std::string& name) const 
+TPT_NO_INLINE Object::const_iterator Object::Find(const std::string& name) const 
 {
    return std::find_if(m_Members.begin(), m_Members.end(), Finder(name));
 }
 
-inline Object::iterator Object::Insert(const Member& member)
+TPT_NO_INLINE Object::iterator Object::Insert(const Member& member)
 {
    return Insert(member, End());
 }
 
-inline Object::iterator Object::Insert(const Member& member, iterator itWhere)
+TPT_NO_INLINE Object::iterator Object::Insert(const Member& member, iterator itWhere)
 {
    iterator it = Find(member.name);
    if (it != m_Members.end())
@@ -298,12 +298,12 @@ inline Object::iterator Object::Insert(const Member& member, iterator itWhere)
    return it;
 }
 
-inline Object::iterator Object::Erase(iterator itWhere) 
+TPT_NO_INLINE Object::iterator Object::Erase(iterator itWhere) 
 {
    return m_Members.erase(itWhere);
 }
 
-inline UnknownElement& Object::operator [](const std::string& name)
+TPT_NO_INLINE UnknownElement& Object::operator [](const std::string& name)
 {
 
    iterator it = Find(name);
@@ -315,7 +315,7 @@ inline UnknownElement& Object::operator [](const std::string& name)
    return it->element;      
 }
 
-inline const UnknownElement& Object::operator [](const std::string& name) const 
+TPT_NO_INLINE const UnknownElement& Object::operator [](const std::string& name) const 
 {
    const_iterator it = Find(name);
    if (it == End())
@@ -323,12 +323,12 @@ inline const UnknownElement& Object::operator [](const std::string& name) const
    return it->element;
 }
 
-inline void Object::Clear() 
+TPT_NO_INLINE void Object::Clear() 
 {
    m_Members.clear(); 
 }
 
-inline bool Object::operator == (const Object& object) const 
+TPT_NO_INLINE bool Object::operator == (const Object& object) const 
 {
    return m_Members == object.m_Members;
 }
@@ -337,35 +337,35 @@ inline bool Object::operator == (const Object& object) const
 /////////////////
 // Array members
 
-inline Array::iterator Array::Begin()  { return m_Elements.begin(); }
-inline Array::iterator Array::End()    { return m_Elements.end(); }
-inline Array::const_iterator Array::Begin() const  { return m_Elements.begin(); }
-inline Array::const_iterator Array::End() const    { return m_Elements.end(); }
+TPT_NO_INLINE Array::iterator Array::Begin()  { return m_Elements.begin(); }
+TPT_NO_INLINE Array::iterator Array::End()    { return m_Elements.end(); }
+TPT_NO_INLINE Array::const_iterator Array::Begin() const  { return m_Elements.begin(); }
+TPT_NO_INLINE Array::const_iterator Array::End() const    { return m_Elements.end(); }
 
-inline Array::iterator Array::Insert(const UnknownElement& element, iterator itWhere)
+TPT_NO_INLINE Array::iterator Array::Insert(const UnknownElement& element, iterator itWhere)
 { 
    return m_Elements.insert(itWhere, element);
 }
 
-inline Array::iterator Array::Insert(const UnknownElement& element)
+TPT_NO_INLINE Array::iterator Array::Insert(const UnknownElement& element)
 {
    return Insert(element, End());
 }
 
-inline Array::iterator Array::Erase(iterator itWhere)
+TPT_NO_INLINE Array::iterator Array::Erase(iterator itWhere)
 { 
    return m_Elements.erase(itWhere);
 }
 
-inline void Array::Resize(size_t newSize)
+TPT_NO_INLINE void Array::Resize(size_t newSize)
 {
    m_Elements.resize(newSize);
 }
 
-inline size_t Array::Size() const  { return m_Elements.size(); }
-inline bool Array::Empty() const   { return m_Elements.empty(); }
+TPT_NO_INLINE size_t Array::Size() const  { return m_Elements.size(); }
+TPT_NO_INLINE bool Array::Empty() const   { return m_Elements.empty(); }
 
-inline UnknownElement& Array::operator[] (size_t index)
+TPT_NO_INLINE UnknownElement& Array::operator[] (size_t index)
 {
    size_t nMinSize = index + 1; // zero indexed
    if (m_Elements.size() < nMinSize)
@@ -373,18 +373,18 @@ inline UnknownElement& Array::operator[] (size_t index)
    return m_Elements[index]; 
 }
 
-inline const UnknownElement& Array::operator[] (size_t index) const 
+TPT_NO_INLINE const UnknownElement& Array::operator[] (size_t index) const 
 {
    if (index >= m_Elements.size())
       throw Exception("Array out of bounds");
    return m_Elements[index]; 
 }
 
-inline void Array::Clear() {
+TPT_NO_INLINE void Array::Clear() {
    m_Elements.clear();
 }
 
-inline bool Array::operator == (const Array& array) const
+TPT_NO_INLINE bool Array::operator == (const Array& array) const
 {
    return m_Elements == array.m_Elements;
 }
@@ -393,7 +393,7 @@ inline bool Array::operator == (const Array& array) const
 //////////////////
 // Null members
 
-inline bool Null::operator == (const Null& trivial) const
+TPT_NO_INLINE bool Null::operator == (const Null& trivial) const
 {
    return true;
 }
diff --git a/src/cajun/elements.h b/src/cajun/elements.h
index 3ddff30..f43b1be 100644
--- a/src/cajun/elements.h
+++ b/src/cajun/elements.h
@@ -35,6 +35,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <stdexcept>
 
+#if defined(_MSC_VER)
+#define TPT_NO_INLINE //Remove inlines in visual studio, but only the ones that don't work
+#else
+#define TPT_NO_INLINE inline
+#endif
+
 /*  
 
 TODO:
diff --git a/src/cajun/reader.cpp b/src/cajun/reader.cpp
index f625367..be35ed1 100644
--- a/src/cajun/reader.cpp
+++ b/src/cajun/reader.cpp
@@ -43,12 +43,12 @@ TODO:
 namespace json
 {
 
-inline std::istream& operator >> (std::istream& istr, UnknownElement& elementRoot) {
+TPT_NO_INLINE std::istream& operator >> (std::istream& istr, UnknownElement& elementRoot) {
    Reader::Read(elementRoot, istr);
    return istr;
 }
 
-inline Reader::Location::Location() :
+TPT_NO_INLINE Reader::Location::Location() :
    m_nLine(0),
    m_nLineOffset(0),
    m_nDocOffset(0)
@@ -84,7 +84,7 @@ private:
 };
 
 
-inline char Reader::InputStream::Get()
+TPT_NO_INLINE char Reader::InputStream::Get()
 {
    assert(m_iStr.eof() == false); // enforce reading of only valid stream data 
    char c = m_iStr.get();
@@ -122,12 +122,12 @@ private:
 };
 
 
-inline Reader::TokenStream::TokenStream(const Tokens& tokens) :
+TPT_NO_INLINE Reader::TokenStream::TokenStream(const Tokens& tokens) :
    m_Tokens(tokens),
    m_itCurrent(tokens.begin())
 {}
 
-inline const Reader::Token& Reader::TokenStream::Peek() {
+TPT_NO_INLINE const Reader::Token& Reader::TokenStream::Peek() {
    if (EOS())
    {
       const Token& lastToken = *m_Tokens.rbegin();
@@ -137,13 +137,13 @@ inline const Reader::Token& Reader::TokenStream::Peek() {
    return *(m_itCurrent); 
 }
 
-inline const Reader::Token& Reader::TokenStream::Get() {
+TPT_NO_INLINE const Reader::Token& Reader::TokenStream::Get() {
    const Token& token = Peek();
    ++m_itCurrent;
    return token;
 }
 
-inline bool Reader::TokenStream::EOS() const {
+TPT_NO_INLINE bool Reader::TokenStream::EOS() const {
    return m_itCurrent == m_Tokens.end(); 
 }
 
@@ -151,13 +151,13 @@ inline bool Reader::TokenStream::EOS() const {
 // Reader (finally)
 
 
-inline void Reader::Read(Object& object, std::istream& istr)                { Read_i(object, istr); }
-inline void Reader::Read(Array& array, std::istream& istr)                  { Read_i(array, istr); }
-inline void Reader::Read(String& string, std::istream& istr)                { Read_i(string, istr); }
-inline void Reader::Read(Number& number, std::istream& istr)                { Read_i(number, istr); }
-inline void Reader::Read(Boolean& boolean, std::istream& istr)              { Read_i(boolean, istr); }
-inline void Reader::Read(Null& null, std::istream& istr)                    { Read_i(null, istr); }
-inline void Reader::Read(UnknownElement& unknown, std::istream& istr)       { Read_i(unknown, istr); }
+TPT_NO_INLINE void Reader::Read(Object& object, std::istream& istr)                { Read_i(object, istr); }
+TPT_NO_INLINE void Reader::Read(Array& array, std::istream& istr)                  { Read_i(array, istr); }
+TPT_NO_INLINE void Reader::Read(String& string, std::istream& istr)                { Read_i(string, istr); }
+TPT_NO_INLINE void Reader::Read(Number& number, std::istream& istr)                { Read_i(number, istr); }
+TPT_NO_INLINE void Reader::Read(Boolean& boolean, std::istream& istr)              { Read_i(boolean, istr); }
+TPT_NO_INLINE void Reader::Read(Null& null, std::istream& istr)                    { Read_i(null, istr); }
+TPT_NO_INLINE void Reader::Read(UnknownElement& unknown, std::istream& istr)       { Read_i(unknown, istr); }
 
 
 template <typename ElementTypeT>   
@@ -181,7 +181,7 @@ void Reader::Read_i(ElementTypeT& element, std::istream& istr)
 }
 
 
-inline void Reader::Scan(Tokens& tokens, InputStream& inputStream)
+TPT_NO_INLINE void Reader::Scan(Tokens& tokens, InputStream& inputStream)
 {
    while (EatWhiteSpace(inputStream),              // ignore any leading white space...
           inputStream.EOS() == false) // ...before checking for EOS
@@ -272,14 +272,14 @@ inline void Reader::Scan(Tokens& tokens, InputStream& inputStream)
 }
 
 
-inline void Reader::EatWhiteSpace(InputStream& inputStream)
+TPT_NO_INLINE void Reader::EatWhiteSpace(InputStream& inputStream)
 {
    while (inputStream.EOS() == false && 
           ::isspace(inputStream.Peek()))
       inputStream.Get();
 }
 
-inline std::string Reader::MatchExpectedString(InputStream& inputStream, const std::string& sExpected)
+TPT_NO_INLINE std::string Reader::MatchExpectedString(InputStream& inputStream, const std::string& sExpected)
 {
    std::string::const_iterator it(sExpected.begin()),
                                itEnd(sExpected.end());
@@ -297,7 +297,7 @@ inline std::string Reader::MatchExpectedString(InputStream& inputStream, const s
 }
 
 
-inline std::string Reader::MatchString(InputStream& inputStream)
+TPT_NO_INLINE std::string Reader::MatchString(InputStream& inputStream)
 {
    MatchExpectedString(inputStream, "\"");
 
@@ -341,7 +341,7 @@ inline std::string Reader::MatchString(InputStream& inputStream)
 }
 
 
-inline std::string Reader::MatchNumber(InputStream& inputStream)
+TPT_NO_INLINE std::string Reader::MatchNumber(InputStream& inputStream)
 {
    const char sNumericChars[] = "0123456789.eE-+";
    std::set<char> numericChars;
@@ -358,7 +358,7 @@ inline std::string Reader::MatchNumber(InputStream& inputStream)
 }
 
 
-inline void Reader::Parse(UnknownElement& element, Reader::TokenStream& tokenStream) 
+TPT_NO_INLINE void Reader::Parse(UnknownElement& element, Reader::TokenStream& tokenStream) 
 {
    const Token& token = tokenStream.Peek();
    switch (token.nType) {
@@ -414,7 +414,7 @@ inline void Reader::Parse(UnknownElement& element, Reader::TokenStream& tokenStr
 }
 
 
-inline void Reader::Parse(Object& object, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE void Reader::Parse(Object& object, Reader::TokenStream& tokenStream)
 {
    MatchExpectedToken(Token::TOKEN_OBJECT_BEGIN, tokenStream);
 
@@ -456,7 +456,7 @@ inline void Reader::Parse(Object& object, Reader::TokenStream& tokenStream)
 }
 
 
-inline void Reader::Parse(Array& array, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE void Reader::Parse(Array& array, Reader::TokenStream& tokenStream)
 {
    MatchExpectedToken(Token::TOKEN_ARRAY_BEGIN, tokenStream);
 
@@ -479,13 +479,13 @@ inline void Reader::Parse(Array& array, Reader::TokenStream& tokenStream)
 }
 
 
-inline void Reader::Parse(String& string, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE void Reader::Parse(String& string, Reader::TokenStream& tokenStream)
 {
    string = MatchExpectedToken(Token::TOKEN_STRING, tokenStream);
 }
 
 
-inline void Reader::Parse(Number& number, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE void Reader::Parse(Number& number, Reader::TokenStream& tokenStream)
 {
    const Token& currentToken = tokenStream.Peek(); // might need this later for throwing exception
    const std::string& sValue = MatchExpectedToken(Token::TOKEN_NUMBER, tokenStream);
@@ -506,20 +506,20 @@ inline void Reader::Parse(Number& number, Reader::TokenStream& tokenStream)
 }
 
 
-inline void Reader::Parse(Boolean& boolean, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE void Reader::Parse(Boolean& boolean, Reader::TokenStream& tokenStream)
 {
    const std::string& sValue = MatchExpectedToken(Token::TOKEN_BOOLEAN, tokenStream);
    boolean = (sValue == "true" ? true : false);
 }
 
 
-inline void Reader::Parse(Null&, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE void Reader::Parse(Null&, Reader::TokenStream& tokenStream)
 {
    MatchExpectedToken(Token::TOKEN_NULL, tokenStream);
 }
 
 
-inline const std::string& Reader::MatchExpectedToken(Token::Type nExpected, Reader::TokenStream& tokenStream)
+TPT_NO_INLINE const std::string& Reader::MatchExpectedToken(Token::Type nExpected, Reader::TokenStream& tokenStream)
 {
    const Token& token = tokenStream.Get();
    if (token.nType != nExpected)
diff --git a/src/cajun/writer.cpp b/src/cajun/writer.cpp
index 446d076..a7cbfbe 100644
--- a/src/cajun/writer.cpp
+++ b/src/cajun/writer.cpp
@@ -43,16 +43,16 @@ namespace json
 {
 
 
-inline void Writer::Write(const UnknownElement& elementRoot, std::ostream& ostr) { Write_i(elementRoot, ostr); }
-inline void Writer::Write(const Object& object, std::ostream& ostr)              { Write_i(object, ostr); }
-inline void Writer::Write(const Array& array, std::ostream& ostr)                { Write_i(array, ostr); }
-inline void Writer::Write(const Number& number, std::ostream& ostr)              { Write_i(number, ostr); }
-inline void Writer::Write(const String& string, std::ostream& ostr)              { Write_i(string, ostr); }
-inline void Writer::Write(const Boolean& boolean, std::ostream& ostr)            { Write_i(boolean, ostr); }
-inline void Writer::Write(const Null& null, std::ostream& ostr)                  { Write_i(null, ostr); }
+TPT_NO_INLINE void Writer::Write(const UnknownElement& elementRoot, std::ostream& ostr) { Write_i(elementRoot, ostr); }
+TPT_NO_INLINE void Writer::Write(const Object& object, std::ostream& ostr)              { Write_i(object, ostr); }
+TPT_NO_INLINE void Writer::Write(const Array& array, std::ostream& ostr)                { Write_i(array, ostr); }
+TPT_NO_INLINE void Writer::Write(const Number& number, std::ostream& ostr)              { Write_i(number, ostr); }
+TPT_NO_INLINE void Writer::Write(const String& string, std::ostream& ostr)              { Write_i(string, ostr); }
+TPT_NO_INLINE void Writer::Write(const Boolean& boolean, std::ostream& ostr)            { Write_i(boolean, ostr); }
+TPT_NO_INLINE void Writer::Write(const Null& null, std::ostream& ostr)                  { Write_i(null, ostr); }
 
 
-inline Writer::Writer(std::ostream& ostr) :
+TPT_NO_INLINE Writer::Writer(std::ostream& ostr) :
    m_ostr(ostr),
    m_nTabDepth(0)
 {}
@@ -65,7 +65,7 @@ void Writer::Write_i(const ElementTypeT& element, std::ostream& ostr)
    ostr.flush(); // all done
 }
 
-inline void Writer::Write_i(const Array& array)
+TPT_NO_INLINE void Writer::Write_i(const Array& array)
 {
    if (array.Empty())
       m_ostr << "[]";
@@ -91,7 +91,7 @@ inline void Writer::Write_i(const Array& array)
    }
 }
 
-inline void Writer::Write_i(const Object& object)
+TPT_NO_INLINE void Writer::Write_i(const Object& object)
 {
    if (object.Empty())
       m_ostr << "{}";
@@ -120,17 +120,17 @@ inline void Writer::Write_i(const Object& object)
    }
 }
 
-inline void Writer::Write_i(const Number& numberElement)
+TPT_NO_INLINE void Writer::Write_i(const Number& numberElement)
 {
    m_ostr << std::setprecision(20) << numberElement.Value();
 }
 
-inline void Writer::Write_i(const Boolean& booleanElement)
+TPT_NO_INLINE void Writer::Write_i(const Boolean& booleanElement)
 {
    m_ostr << (booleanElement.Value() ? "true" : "false");
 }
 
-inline void Writer::Write_i(const String& stringElement)
+TPT_NO_INLINE void Writer::Write_i(const String& stringElement)
 {
    m_ostr << '"';
 
@@ -156,22 +156,22 @@ inline void Writer::Write_i(const String& stringElement)
    m_ostr << '"';   
 }
 
-inline void Writer::Write_i(const Null& )
+TPT_NO_INLINE void Writer::Write_i(const Null& )
 {
    m_ostr << "null";
 }
 
-inline void Writer::Write_i(const UnknownElement& unknown)
+TPT_NO_INLINE void Writer::Write_i(const UnknownElement& unknown)
 {
    unknown.Accept(*this); 
 }
 
-inline void Writer::Visit(const Array& array)       { Write_i(array); }
-inline void Writer::Visit(const Object& object)     { Write_i(object); }
-inline void Writer::Visit(const Number& number)     { Write_i(number); }
-inline void Writer::Visit(const String& string)     { Write_i(string); }
-inline void Writer::Visit(const Boolean& boolean)   { Write_i(boolean); }
-inline void Writer::Visit(const Null& null)         { Write_i(null); }
+TPT_NO_INLINE void Writer::Visit(const Array& array)       { Write_i(array); }
+TPT_NO_INLINE void Writer::Visit(const Object& object)     { Write_i(object); }
+TPT_NO_INLINE void Writer::Visit(const Number& number)     { Write_i(number); }
+TPT_NO_INLINE void Writer::Visit(const String& string)     { Write_i(string); }
+TPT_NO_INLINE void Writer::Visit(const Boolean& boolean)   { Write_i(boolean); }
+TPT_NO_INLINE void Writer::Visit(const Null& null)         { Write_i(null); }