zhaobu
/
zhujimajiang_redis
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
诸暨麻将添加redis
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
6 提交
2 分支
57 MiB
 
 
 
 
 
 
目录树: 522a9556dd
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '522a9556dd'
${ noResults }
zhujimajiang_redis/俱乐部/Source/ServerControl/Json/json_writer.cpp

831 行
20 KiB
原始文件 Blame 文件历史 

  1. # include "stdafx.h"

  2. #include "writer.h"

  3. #include <utility>

  4. #include <assert.h>

  5. #include <stdio.h>

  6. #include <string.h>

  7. #include <iostream>

  8. #include <sstream>

  9. #include <iomanip>

  10. 

  11. #if _MSC_VER >= 1400 // VC++ 8.0

  12. #pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.

  13. #endif

  14. 

  15. namespace Json {

  16. 

  17. static bool isControlCharacter(char ch)

  18. {

  19.    return ch > 0 && ch <= 0x1F;

  20. }

  21. 

  22. static bool containsControlCharacter( const char* str )

  23. {

  24.    while ( *str ) 

  25.    {

  26.       if ( isControlCharacter( *(str++) ) )

  27.          return true;

  28.    }

  29.    return false;

  30. }

  31. static void uintToString( unsigned int value, 

  32.                           char *&current )

  33. {

  34.    *--current = 0;

  35.    do

  36.    {

  37.       *--current = (value % 10) + '0';

  38.       value /= 10;

  39.    }

  40.    while ( value != 0 );

  41. }

  42. 

  43. std::string valueToString( Int value )

  44. {

  45.    char buffer[32];

  46.    char *current = buffer + sizeof(buffer);

  47.    bool isNegative = value < 0;

  48.    if ( isNegative )

  49.       value = -value;

  50.    uintToString( UInt(value), current );

  51.    if ( isNegative )

  52.       *--current = '-';

  53.    assert( current >= buffer );

  54.    return current;

  55. }

  56. 

  57. 

  58. std::string valueToString( UInt value )

  59. {

  60.    char buffer[32];

  61.    char *current = buffer + sizeof(buffer);

  62.    uintToString( value, current );

  63.    assert( current >= buffer );

  64.    return current;

  65. }

  66. 

  67. std::string valueToString( double value )

  68. {

  69.    char buffer[32];

  70. #if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with visual studio 2005 to avoid warning. 

  71.    sprintf_s(buffer, sizeof(buffer), "%#.16g", value); 

  72. #else	

  73.    sprintf(buffer, "%#.16g", value); 

  74. #endif

  75.    char* ch = buffer + strlen(buffer) - 1;

  76.    if (*ch != '0') return buffer; // nothing to truncate, so save time

  77.    while(ch > buffer && *ch == '0'){

  78.      --ch;

  79.    }

  80.    char* last_nonzero = ch;

  81.    while(ch >= buffer){

  82.      switch(*ch){

  83.      case '0':

  84.      case '1':

  85.      case '2':

  86.      case '3':

  87.      case '4':

  88.      case '5':

  89.      case '6':

  90.      case '7':

  91.      case '8':

  92.      case '9':

  93.        --ch;

  94.        continue;

  95.      case '.':

  96.        // Truncate zeroes to save bytes in output, but keep one.

  97.        *(last_nonzero+2) = '\0';

  98.        return buffer;

  99.      default:

  100.        return buffer;

  101.      }

  102.    }

  103.    return buffer;

  104. }

  105. 

  106. 

  107. std::string valueToString( bool value )

  108. {

  109.    return value ? "true" : "false";

  110. }

  111. 

  112. std::string valueToQuotedString( const char *value )

  113. {

  114.    // Not sure how to handle unicode...

  115.    if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter( value ))

  116.       return std::string("\"") + value + "\"";

  117.    // We have to walk value and escape any special characters.

  118.    // Appending to std::string is not efficient, but this should be rare.

  119.    // (Note: forward slashes are *not* rare, but I am not escaping them.)

  120.    unsigned maxsize = strlen(value)*2 + 3; // allescaped+quotes+NULL

  121.    std::string result;

  122.    result.reserve(maxsize); // to avoid lots of mallocs

  123.    result += "\"";

  124.    for (const char* c=value; *c != 0; ++c)

  125.    {

  126.       switch(*c)

  127.       {

  128.          case '\"':

  129.             result += "\\\"";

  130.             break;

  131.          case '\\':

  132.             result += "\\\\";

  133.             break;

  134.          case '\b':

  135.             result += "\\b";

  136.             break;

  137.          case '\f':

  138.             result += "\\f";

  139.             break;

  140.          case '\n':

  141.             result += "\\n";

  142.             break;

  143.          case '\r':

  144.             result += "\\r";

  145.             break;

  146.          case '\t':

  147.             result += "\\t";

  148.             break;

  149.          //case '/':

  150.             // Even though \/ is considered a legal escape in JSON, a bare

  151.             // slash is also legal, so I see no reason to escape it.

  152.             // (I hope I am not misunderstanding something.

  153.             // blep notes: actually escaping \/ may be useful in javascript to avoid </ 

  154.             // sequence.

  155.             // Should add a flag to allow this compatibility mode and prevent this 

  156.             // sequence from occurring.

  157.          default:

  158.             if ( isControlCharacter( *c ) )

  159.             {

  160.                std::ostringstream oss;

  161.                oss << "\\u" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<int>(*c);

  162.                result += oss.str();

  163.             }

  164.             else

  165.             {

  166.                result += *c;

  167.             }

  168.             break;

  169.       }

  170.    }

  171.    result += "\"";

  172.    return result;

  173. }

  174. 

  175. // Class Writer

  176. // //////////////////////////////////////////////////////////////////

  177. Writer::~Writer()

  178. {

  179. }

  180. 

  181. 

  182. // Class FastWriter

  183. // //////////////////////////////////////////////////////////////////

  184. 

  185. FastWriter::FastWriter()

  186.    : yamlCompatiblityEnabled_( false )

  187. {

  188. }

  189. 

  190. 

  191. void 

  192. FastWriter::enableYAMLCompatibility()

  193. {

  194.    yamlCompatiblityEnabled_ = true;

  195. }

  196. 

  197. 

  198. std::string 

  199. FastWriter::write( const Value &root )

  200. {

  201.    document_ = "";

  202.    writeValue( root );

  203.    document_ += "\n";

  204.    return document_;

  205. }

  206. 

  207. 

  208. void 

  209. FastWriter::writeValue( const Value &value )

  210. {

  211.    switch ( value.type() )

  212.    {

  213.    case nullValue:

  214.       document_ += "null";

  215.       break;

  216.    case intValue:

  217.       document_ += valueToString( value.asInt() );

  218.       break;

  219.    case uintValue:

  220.       document_ += valueToString( value.asUInt() );

  221.       break;

  222.    case realValue:

  223.       document_ += valueToString( value.asDouble() );

  224.       break;

  225.    case stringValue:

  226.       document_ += valueToQuotedString( value.asCString() );

  227.       break;

  228.    case booleanValue:

  229.       document_ += valueToString( value.asBool() );

  230.       break;

  231.    case arrayValue:

  232.       {

  233.          document_ += "[";

  234.          int size = value.size();

  235.          for ( int index =0; index < size; ++index )

  236.          {

  237.             if ( index > 0 )

  238.                document_ += ",";

  239.             writeValue( value[index] );

  240.          }

  241.          document_ += "]";

  242.       }

  243.       break;

  244.    case objectValue:

  245.       {

  246.          Value::Members members( value.getMemberNames() );

  247.          document_ += "{";

  248.          for ( Value::Members::iterator it = members.begin(); 

  249.                it != members.end(); 

  250.                ++it )

  251.          {

  252.             const std::string &name = *it;

  253.             if ( it != members.begin() )

  254.                document_ += ",";

  255.             document_ += valueToQuotedString( name.c_str() );

  256.             document_ += yamlCompatiblityEnabled_ ? ": " 

  257.                                                   : ":";

  258.             writeValue( value[name] );

  259.          }

  260.          document_ += "}";

  261.       }

  262.       break;

  263.    }

  264. }

  265. 

  266. 

  267. // Class StyledWriter

  268. // //////////////////////////////////////////////////////////////////

  269. 

  270. StyledWriter::StyledWriter()

  271.    : rightMargin_( 74 )

  272.    , indentSize_( 3 )

  273. {

  274. }

  275. 

  276. 

  277. std::string 

  278. StyledWriter::write( const Value &root )

  279. {

  280.    document_ = "";

  281.    addChildValues_ = false;

  282.    indentString_ = "";

  283.    writeCommentBeforeValue( root );

  284.    writeValue( root );

  285.    writeCommentAfterValueOnSameLine( root );

  286.    document_ += "\n";

  287.    return document_;

  288. }

  289. 

  290. 

  291. void 

  292. StyledWriter::writeValue( const Value &value )

  293. {

  294.    switch ( value.type() )

  295.    {

  296.    case nullValue:

  297.       pushValue( "null" );

  298.       break;

  299.    case intValue:

  300.       pushValue( valueToString( value.asInt() ) );

  301.       break;

  302.    case uintValue:

  303.       pushValue( valueToString( value.asUInt() ) );

  304.       break;

  305.    case realValue:

  306.       pushValue( valueToString( value.asDouble() ) );

  307.       break;

  308.    case stringValue:

  309.       pushValue( valueToQuotedString( value.asCString() ) );

  310.       break;

  311.    case booleanValue:

  312.       pushValue( valueToString( value.asBool() ) );

  313.       break;

  314.    case arrayValue:

  315.       writeArrayValue( value);

  316.       break;

  317.    case objectValue:

  318.       {

  319.          Value::Members members( value.getMemberNames() );

  320.          if ( members.empty() )

  321.             pushValue( "{}" );

  322.          else

  323.          {

  324.             writeWithIndent( "{" );

  325.             indent();

  326.             Value::Members::iterator it = members.begin();

  327.             while ( true )

  328.             {

  329.                const std::string &name = *it;

  330.                const Value &childValue = value[name];

  331.                writeCommentBeforeValue( childValue );

  332.                writeWithIndent( valueToQuotedString( name.c_str() ) );

  333.                document_ += " : ";

  334.                writeValue( childValue );

  335.                if ( ++it == members.end() )

  336.                {

  337.                   writeCommentAfterValueOnSameLine( childValue );

  338.                   break;

  339.                }

  340.                document_ += ",";

  341.                writeCommentAfterValueOnSameLine( childValue );

  342.             }

  343.             unindent();

  344.             writeWithIndent( "}" );

  345.          }

  346.       }

  347.       break;

  348.    }

  349. }

  350. 

  351. 

  352. void 

  353. StyledWriter::writeArrayValue( const Value &value )

  354. {

  355.    unsigned size = value.size();

  356.    if ( size == 0 )

  357.       pushValue( "[]" );

  358.    else

  359.    {

  360.       bool isArrayMultiLine = isMultineArray( value );

  361.       if ( isArrayMultiLine )

  362.       {

  363.          writeWithIndent( "[" );

  364.          indent();

  365.          bool hasChildValue = !childValues_.empty();

  366.          unsigned index =0;

  367.          while ( true )

  368.          {

  369.             const Value &childValue = value[index];

  370.             writeCommentBeforeValue( childValue );

  371.             if ( hasChildValue )

  372.                writeWithIndent( childValues_[index] );

  373.             else

  374.             {

  375.                writeIndent();

  376.                writeValue( childValue );

  377.             }

  378.             if ( ++index == size )

  379.             {

  380.                writeCommentAfterValueOnSameLine( childValue );

  381.                break;

  382.             }

  383.             document_ += ",";

  384.             writeCommentAfterValueOnSameLine( childValue );

  385.          }

  386.          unindent();

  387.          writeWithIndent( "]" );

  388.       }

  389.       else // output on a single line

  390.       {

  391.          assert( childValues_.size() == size );

  392.          document_ += "[ ";

  393.          for ( unsigned index =0; index < size; ++index )

  394.          {

  395.             if ( index > 0 )

  396.                document_ += ", ";

  397.             document_ += childValues_[index];

  398.          }

  399.          document_ += " ]";

  400.       }

  401.    }

  402. }

  403. 

  404. 

  405. bool 

  406. StyledWriter::isMultineArray( const Value &value )

  407. {

  408.    int size = value.size();

  409.    bool isMultiLine = size*3 >= rightMargin_ ;

  410.    childValues_.clear();

  411.    for ( int index =0; index < size  &&  !isMultiLine; ++index )

  412.    {

  413.       const Value &childValue = value[index];

  414.       isMultiLine = isMultiLine  ||

  415.                      ( (childValue.isArray()  ||  childValue.isObject())  &&  

  416.                         childValue.size() > 0 );

  417.    }

  418.    if ( !isMultiLine ) // check if line length > max line length

  419.    {

  420.       childValues_.reserve( size );

  421.       addChildValues_ = true;

  422.       int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'

  423.       for ( int index =0; index < size  &&  !isMultiLine; ++index )

  424.       {

  425.          writeValue( value[index] );

  426.          lineLength += int( childValues_[index].length() );

  427.          isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );

  428.       }

  429.       addChildValues_ = false;

  430.       isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;

  431.    }

  432.    return isMultiLine;

  433. }

  434. 

  435. 

  436. void 

  437. StyledWriter::pushValue( const std::string &value )

  438. {

  439.    if ( addChildValues_ )

  440.       childValues_.push_back( value );

  441.    else

  442.       document_ += value;

  443. }

  444. 

  445. 

  446. void 

  447. StyledWriter::writeIndent()

  448. {

  449.    if ( !document_.empty() )

  450.    {

  451.       char last = document_[document_.length()-1];

  452.       if ( last == ' ' )     // already indented

  453.          return;

  454.       if ( last != '\n' )    // Comments may add new-line

  455.          document_ += '\n';

  456.    }

  457.    document_ += indentString_;

  458. }

  459. 

  460. 

  461. void 

  462. StyledWriter::writeWithIndent( const std::string &value )

  463. {

  464.    writeIndent();

  465.    document_ += value;

  466. }

  467. 

  468. 

  469. void 

  470. StyledWriter::indent()

  471. {

  472.    indentString_ += std::string( indentSize_, ' ' );

  473. }

  474. 

  475. 

  476. void 

  477. StyledWriter::unindent()

  478. {

  479.    assert( int(indentString_.size()) >= indentSize_ );

  480.    indentString_.resize( indentString_.size() - indentSize_ );

  481. }

  482. 

  483. 

  484. void 

  485. StyledWriter::writeCommentBeforeValue( const Value &root )

  486. {

  487.    if ( !root.hasComment( commentBefore ) )

  488.       return;

  489.    document_ += normalizeEOL( root.getComment( commentBefore ) );

  490.    document_ += "\n";

  491. }

  492. 

  493. 

  494. void 

  495. StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )

  496. {

  497.    if ( root.hasComment( commentAfterOnSameLine ) )

  498.       document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );

  499. 

  500.    if ( root.hasComment( commentAfter ) )

  501.    {

  502.       document_ += "\n";

  503.       document_ += normalizeEOL( root.getComment( commentAfter ) );

  504.       document_ += "\n";

  505.    }

  506. }

  507. 

  508. 

  509. bool 

  510. StyledWriter::hasCommentForValue( const Value &value )

  511. {

  512.    return value.hasComment( commentBefore )

  513.           ||  value.hasComment( commentAfterOnSameLine )

  514.           ||  value.hasComment( commentAfter );

  515. }

  516. 

  517. 

  518. std::string 

  519. StyledWriter::normalizeEOL( const std::string &text )

  520. {

  521.    std::string normalized;

  522.    normalized.reserve( text.length() );

  523.    const char *begin = text.c_str();

  524.    const char *end = begin + text.length();

  525.    const char *current = begin;

  526.    while ( current != end )

  527.    {

  528.       char c = *current++;

  529.       if ( c == '\r' ) // mac or dos EOL

  530.       {

  531.          if ( *current == '\n' ) // convert dos EOL

  532.             ++current;

  533.          normalized += '\n';

  534.       }

  535.       else // handle unix EOL & other char

  536.          normalized += c;

  537.    }

  538.    return normalized;

  539. }

  540. 

  541. 

  542. // Class StyledStreamWriter

  543. // //////////////////////////////////////////////////////////////////

  544. 

  545. StyledStreamWriter::StyledStreamWriter( std::string indentation )

  546.    : document_(NULL)

  547.    , rightMargin_( 74 )

  548.    , indentation_( indentation )

  549. {

  550. }

  551. 

  552. 

  553. void

  554. StyledStreamWriter::write( std::ostream &out, const Value &root )

  555. {

  556.    document_ = &out;

  557.    addChildValues_ = false;

  558.    indentString_ = "";

  559.    writeCommentBeforeValue( root );

  560.    writeValue( root );

  561.    writeCommentAfterValueOnSameLine( root );

  562.    *document_ << "\n";

  563.    document_ = NULL; // Forget the stream, for safety.

  564. }

  565. 

  566. 

  567. void 

  568. StyledStreamWriter::writeValue( const Value &value )

  569. {

  570.    switch ( value.type() )

  571.    {

  572.    case nullValue:

  573.       pushValue( "null" );

  574.       break;

  575.    case intValue:

  576.       pushValue( valueToString( value.asInt() ) );

  577.       break;

  578.    case uintValue:

  579.       pushValue( valueToString( value.asUInt() ) );

  580.       break;

  581.    case realValue:

  582.       pushValue( valueToString( value.asDouble() ) );

  583.       break;

  584.    case stringValue:

  585.       pushValue( valueToQuotedString( value.asCString() ) );

  586.       break;

  587.    case booleanValue:

  588.       pushValue( valueToString( value.asBool() ) );

  589.       break;

  590.    case arrayValue:

  591.       writeArrayValue( value);

  592.       break;

  593.    case objectValue:

  594.       {

  595.          Value::Members members( value.getMemberNames() );

  596.          if ( members.empty() )

  597.             pushValue( "{}" );

  598.          else

  599.          {

  600.             writeWithIndent( "{" );

  601.             indent();

  602.             Value::Members::iterator it = members.begin();

  603.             while ( true )

  604.             {

  605.                const std::string &name = *it;

  606.                const Value &childValue = value[name];

  607.                writeCommentBeforeValue( childValue );

  608.                writeWithIndent( valueToQuotedString( name.c_str() ) );

  609.                *document_ << " : ";

  610.                writeValue( childValue );

  611.                if ( ++it == members.end() )

  612.                {

  613.                   writeCommentAfterValueOnSameLine( childValue );

  614.                   break;

  615.                }

  616.                *document_ << ",";

  617.                writeCommentAfterValueOnSameLine( childValue );

  618.             }

  619.             unindent();

  620.             writeWithIndent( "}" );

  621.          }

  622.       }

  623.       break;

  624.    }

  625. }

  626. 

  627. 

  628. void 

  629. StyledStreamWriter::writeArrayValue( const Value &value )

  630. {

  631.    unsigned size = value.size();

  632.    if ( size == 0 )

  633.       pushValue( "[]" );

  634.    else

  635.    {

  636.       bool isArrayMultiLine = isMultineArray( value );

  637.       if ( isArrayMultiLine )

  638.       {

  639.          writeWithIndent( "[" );

  640.          indent();

  641.          bool hasChildValue = !childValues_.empty();

  642.          unsigned index =0;

  643.          while ( true )

  644.          {

  645.             const Value &childValue = value[index];

  646.             writeCommentBeforeValue( childValue );

  647.             if ( hasChildValue )

  648.                writeWithIndent( childValues_[index] );

  649.             else

  650.             {

  651. 	       writeIndent();

  652.                writeValue( childValue );

  653.             }

  654.             if ( ++index == size )

  655.             {

  656.                writeCommentAfterValueOnSameLine( childValue );

  657.                break;

  658.             }

  659.             *document_ << ",";

  660.             writeCommentAfterValueOnSameLine( childValue );

  661.          }

  662.          unindent();

  663.          writeWithIndent( "]" );

  664.       }

  665.       else // output on a single line

  666.       {

  667.          assert( childValues_.size() == size );

  668.          *document_ << "[ ";

  669.          for ( unsigned index =0; index < size; ++index )

  670.          {

  671.             if ( index > 0 )

  672.                *document_ << ", ";

  673.             *document_ << childValues_[index];

  674.          }

  675.          *document_ << " ]";

  676.       }

  677.    }

  678. }

  679. 

  680. 

  681. bool 

  682. StyledStreamWriter::isMultineArray( const Value &value )

  683. {

  684.    int size = value.size();

  685.    bool isMultiLine = size*3 >= rightMargin_ ;

  686.    childValues_.clear();

  687.    for ( int index =0; index < size  &&  !isMultiLine; ++index )

  688.    {

  689.       const Value &childValue = value[index];

  690.       isMultiLine = isMultiLine  ||

  691.                      ( (childValue.isArray()  ||  childValue.isObject())  &&  

  692.                         childValue.size() > 0 );

  693.    }

  694.    if ( !isMultiLine ) // check if line length > max line length

  695.    {

  696.       childValues_.reserve( size );

  697.       addChildValues_ = true;

  698.       int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'

  699.       for ( int index =0; index < size  &&  !isMultiLine; ++index )

  700.       {

  701.          writeValue( value[index] );

  702.          lineLength += int( childValues_[index].length() );

  703.          isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );

  704.       }

  705.       addChildValues_ = false;

  706.       isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;

  707.    }

  708.    return isMultiLine;

  709. }

  710. 

  711. 

  712. void 

  713. StyledStreamWriter::pushValue( const std::string &value )

  714. {

  715.    if ( addChildValues_ )

  716.       childValues_.push_back( value );

  717.    else

  718.       *document_ << value;

  719. }

  720. 

  721. 

  722. void 

  723. StyledStreamWriter::writeIndent()

  724. {

  725.   /*

  726.     Some comments in this method would have been nice. ;-)

  727. 

  728.    if ( !document_.empty() )

  729.    {

  730.       char last = document_[document_.length()-1];

  731.       if ( last == ' ' )     // already indented

  732.          return;

  733.       if ( last != '\n' )    // Comments may add new-line

  734.          *document_ << '\n';

  735.    }

  736.   */

  737.    *document_ << '\n' << indentString_;

  738. }

  739. 

  740. 

  741. void 

  742. StyledStreamWriter::writeWithIndent( const std::string &value )

  743. {

  744.    writeIndent();

  745.    *document_ << value;

  746. }

  747. 

  748. 

  749. void 

  750. StyledStreamWriter::indent()

  751. {

  752.    indentString_ += indentation_;

  753. }

  754. 

  755. 

  756. void 

  757. StyledStreamWriter::unindent()

  758. {

  759.    assert( indentString_.size() >= indentation_.size() );

  760.    indentString_.resize( indentString_.size() - indentation_.size() );

  761. }

  762. 

  763. 

  764. void 

  765. StyledStreamWriter::writeCommentBeforeValue( const Value &root )

  766. {

  767.    if ( !root.hasComment( commentBefore ) )

  768.       return;

  769.    *document_ << normalizeEOL( root.getComment( commentBefore ) );

  770.    *document_ << "\n";

  771. }

  772. 

  773. 

  774. void 

  775. StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )

  776. {

  777.    if ( root.hasComment( commentAfterOnSameLine ) )

  778.       *document_ << " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );

  779. 

  780.    if ( root.hasComment( commentAfter ) )

  781.    {

  782.       *document_ << "\n";

  783.       *document_ << normalizeEOL( root.getComment( commentAfter ) );

  784.       *document_ << "\n";

  785.    }

  786. }

  787. 

  788. 

  789. bool 

  790. StyledStreamWriter::hasCommentForValue( const Value &value )

  791. {

  792.    return value.hasComment( commentBefore )

  793.           ||  value.hasComment( commentAfterOnSameLine )

  794.           ||  value.hasComment( commentAfter );

  795. }

  796. 

  797. 

  798. std::string 

  799. StyledStreamWriter::normalizeEOL( const std::string &text )

  800. {

  801.    std::string normalized;

  802.    normalized.reserve( text.length() );

  803.    const char *begin = text.c_str();

  804.    const char *end = begin + text.length();

  805.    const char *current = begin;

  806.    while ( current != end )

  807.    {

  808.       char c = *current++;

  809.       if ( c == '\r' ) // mac or dos EOL

  810.       {

  811.          if ( *current == '\n' ) // convert dos EOL

  812.             ++current;

  813.          normalized += '\n';

  814.       }

  815.       else // handle unix EOL & other char

  816.          normalized += c;

  817.    }

  818.    return normalized;

  819. }

  820. 

  821. 

  822. std::ostream& operator<<( std::ostream &sout, const Value &root )

  823. {

  824.    Json::StyledStreamWriter writer;

  825.    writer.write(sout, root);

  826.    return sout;

  827. }

  828. 

  829. 

  830. } // namespace Json