Esempio n. 1
0
void 
StyledStreamWriter::writeValue( const Value &value )
{
   switch ( value.type() )
   {
   case nullValue:
      pushValue( "null" );
      break;
   case intValue:
      pushValue( valueToString( value.asLargestInt() ) );
      break;
   case uintValue:
      pushValue( valueToString( value.asLargestUInt() ) );
      break;
   case realValue:
      pushValue( valueToString( value.asDouble() ) );
      break;
   case stringValue:
      pushValue( valueToQuotedString( value.asCString() ) );
      break;
   case booleanValue:
      pushValue( valueToString( value.asBool() ) );
      break;
   case arrayValue:
      writeArrayValue( value);
      break;
   case objectValue:
      {
         Value::Members members( value.getMemberNames() );
         if ( members.empty() )
            pushValue( "{}" );
         else
         {
            writeWithIndent( "{" );
            indent();
            Value::Members::iterator it = members.begin();
            for (;;)
            {
               const std::string &name = *it;
               const Value &childValue = value[name];
               writeCommentBeforeValue( childValue );
               writeWithIndent( valueToQuotedString( name.c_str() ) );
               *document_ << " : ";
               writeValue( childValue );
               if ( ++it == members.end() )
               {
                  writeCommentAfterValueOnSameLine( childValue );
                  break;
               }
               *document_ << ",";
               writeCommentAfterValueOnSameLine( childValue );
            }
            unindent();
            writeWithIndent( "}" );
         }
      }
      break;
   }
}
Esempio n. 2
0
void 
FastWriter::writeValue( const Value &value )
{
   switch ( value.type() )
   {
   case nullValue:
      document_ += "null";
      break;
   case intValue:
      document_ += valueToString( value.asLargestInt() );
      break;
   case uintValue:
      document_ += valueToString( value.asLargestUInt() );
      break;
   case realValue:
      document_ += valueToString( value.asDouble() );
      break;
   case stringValue:
      document_ += valueToQuotedString( value.asCString() );
      break;
   case booleanValue:
      document_ += valueToString( value.asBool() );
      break;
   case arrayValue:
      {
         document_ += "[";
         int size = value.size();
         for ( int index =0; index < size; ++index )
         {
            if ( index > 0 )
               document_ += ",";
            writeValue( value[index] );
         }
         document_ += "]";
      }
      break;
   case objectValue:
      {
         Value::Members members( value.getMemberNames() );
         document_ += "{";
         for ( Value::Members::iterator it = members.begin(); 
               it != members.end(); 
               ++it )
         {
            const std::string &name = *it;
            if ( it != members.begin() )
               document_ += ",";
            document_ += valueToQuotedString( name.c_str() );
            document_ += yamlCompatiblityEnabled_ ? ": " 
                                                  : ":";
            writeValue( value[name] );
         }
         document_ += "}";
      }
      break;
   }
}
Esempio n. 3
0
void StyledStreamWriter::writeValue(const Value& value) {
    switch (value.type()) {
    case nullValue:
        pushValue("null");
        break;
    case intValue:
        pushValue(valueToString(value.asLargestInt()));
        break;
    case uintValue:
        pushValue(valueToString(value.asLargestUInt()));
        break;
    case realValue:
        pushValue(valueToString(value.asDouble()));
        break;
    case stringValue:
    {
        // Is NULL possible for value.string_?
        char const* str;
        char const* end;
        bool ok = value.getString(&str, &end);
        if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
        else pushValue("");
        break;
    }
    case booleanValue:
        pushValue(valueToString(value.asBool()));
        break;
    case arrayValue:
        writeArrayValue(value);
        break;
    case objectValue: {
        Value::Members members(value.getMemberNames());
        if (members.empty())
            pushValue("{}");
        else {
            writeWithIndent("{");
            indent();
            Value::Members::iterator it = members.begin();
            for (;;) {
                const std::string& name = *it;
                const Value& childValue = value[name];
                writeCommentBeforeValue(childValue);
                writeWithIndent(valueToQuotedString(name.c_str()));
                *document_ << " : ";
                writeValue(childValue);
                if (++it == members.end()) {
                    writeCommentAfterValueOnSameLine(childValue);
                    break;
                }
                *document_ << ",";
                writeCommentAfterValueOnSameLine(childValue);
            }
            unindent();
            writeWithIndent("}");
        }
    }
    break;
    }
}
Esempio n. 4
0
void
write_value (write_t write, Value const& value)
{
    switch (value.type())
    {
    case nullValue:
        write("null", 4);
        break;

    case intValue:
        write_string(write, valueToString(value.asInt()));
        break;

    case uintValue:
        write_string(write, valueToString(value.asUInt()));
        break;

    case realValue:
        write_string(write, valueToString(value.asDouble()));
        break;

    case stringValue:
        write_string(write, valueToQuotedString(value.asCString()));
        break;

    case booleanValue:
        write_string(write, valueToString(value.asBool()));
        break;

    case arrayValue:
    {
        write("[", 1);
        int const size = value.size();
        for (int index = 0; index < size; ++index)
        {
            if (index > 0)
                write(",", 1);
            write_value(write, value[index]);
        }
        write("]", 1);
        break;
    }

    case objectValue:
    {
        Value::Members const members = value.getMemberNames();
        write("{", 1);
        for (auto it = members.begin(); it != members.end(); ++it)
        {
            std::string const& name = *it;
            if (it != members.begin())
                write(",", 1);

            write_string(write, valueToQuotedString(name.c_str()));
            write(":", 1);
            write_value(write, value[name]);
        }
        write("}", 1);
        break;
    }
    }
}
Esempio n. 5
0
void
StyledWriter::writeValue ( const Value& value )
{
    switch ( value.type () )
    {
    case nullValue:
        pushValue ( "null" );
        break;

    case intValue:
        pushValue ( valueToString ( value.asInt () ) );
        break;

    case uintValue:
        pushValue ( valueToString ( value.asUInt () ) );
        break;

    case realValue:
        pushValue ( valueToString ( value.asDouble () ) );
        break;

    case stringValue:
        pushValue ( valueToQuotedString ( value.asCString () ) );
        break;

    case booleanValue:
        pushValue ( valueToString ( value.asBool () ) );
        break;

    case arrayValue:
        writeArrayValue ( value);
        break;

    case objectValue:
    {
        Value::Members members ( value.getMemberNames () );

        if ( members.empty () )
            pushValue ( "{}" );
        else
        {
            writeWithIndent ( "{" );
            indent ();
            Value::Members::iterator it = members.begin ();

            while ( true )
            {
                std::string const& name = *it;
                const Value& childValue = value[name];
                writeWithIndent ( valueToQuotedString ( name.c_str () ) );
                document_ += " : ";
                writeValue ( childValue );

                if ( ++it == members.end () )
                    break;

                document_ += ",";
            }

            unindent ();
            writeWithIndent ( "}" );
        }
    }
    break;
    }
}
Esempio n. 6
0
 void HTMLWriter::writeValue(std::string &document, const Value &value)
 {
     switch(value.type()) {
     case nullValue:
         break;
     case intValue:
         document += valueToString(value.asLargestInt());
         break;
     case uintValue:
         document += valueToString(value.asLargestUInt());
         break;
     case realValue:
         document += valueToString(value.asDouble());
         break;
     case stringValue:
         document += valueToQuotedString(value.asString().c_str());
         break;
     case booleanValue:
         document += value.asBool();
         break;
     case arrayValue: {
         document += "<ol>";
         for (uint8_t index = 0; index < value.size(); index++) {
             switch(value[index].type()) {
             case nullValue:
             case intValue:
             case uintValue:
             case realValue:
             case stringValue:
             case booleanValue:
                 writeIndent(document);
                 document += "<li>";
                 writeValue(document, value[index]);
                 document += "</li>";
                 document += "\n";
                 break;
             case arrayValue:
             case objectValue:
                 depth++;
                 document += "<li>";
                 writeValue(document, value[index]);
                 depth--;
                 document += "</li>";
                 break;
             }
         }
         break;
     }
     case objectValue: {
         Value::Members members(value.getMemberNames());
         if (depth == 0) {
             document += "<dl class='la_results'>";
         } else {
             document += "<dl>";
         }
         for (Value::Members::iterator it = members.begin();
              it != members.end(); ++it) {
             const std::string &name = *it;
             writeIndent(document);
             document += "<dt>";
             document += name;
             document += "</dt>\n";
             writeIndent(document);
             document += "<dd>";
             switch(value[name].type()) {
             case nullValue:
             case intValue:
             case uintValue:
             case realValue:
             case stringValue:
             case booleanValue:
                 writeValue(document, value[name]);
                 break;
             case arrayValue:
             case objectValue:
                 depth++;
                 writeValue(document, value[name]);
                 depth--;
             }
             document += "</dd>\n";
         }
         document += "</dl>\n";
         break;
     }
     }
 }
Esempio n. 7
0
 void PlainTextWriter::writeValue(std::string &document, const Value &value)
 {
     switch(value.type()) {
     case nullValue:
         break;
     case intValue:
         document += valueToString(value.asLargestInt());
         break;
     case uintValue:
         document += valueToString(value.asLargestUInt());
         break;
     case realValue:
         document += valueToString(value.asDouble());
         break;
     case stringValue:
         document += valueToQuotedString(value.asString().c_str());
         break;
     case booleanValue:
         document += value.asBool();
         break;
     case arrayValue: {
         for (uint8_t index = 0; index < value.size(); index++) {
             switch(value[index].type()) {
             case nullValue:
             case intValue:
             case uintValue:
             case realValue:
             case stringValue:
             case booleanValue:
                 writeIndent(document);
                 writeValue(document, value[index]);
                 document += "\n";
                 break;
             case arrayValue:
             case objectValue:
                 depth++;
                 writeValue(document, value[index]);
                 depth--;
                 break;
             }
         }
         break;
     }
     case objectValue: {
         Value::Members members(value.getMemberNames());
         for (Value::Members::iterator it = members.begin();
              it != members.end(); ++it) {
             const std::string &name = *it;
             writeIndent(document);
             document += name;
             document += ":";
             switch(value[name].type()) {
             case nullValue:
             case intValue:
             case uintValue:
             case realValue:
             case stringValue:
             case booleanValue:
                 document += " ";
                 writeValue(document, value[name]);
                 document += "\n";
                 break;
             case arrayValue:
             case objectValue:
                 document += "\n";
                 depth++;
                 writeValue(document, value[name]);
                 depth--;
             }
         }
         break;
     }
     }
 }