bool RegExpController::saveToFile(const QString &filename)
{
    QFile file(filename);
    if (!file.open(QFile::WriteOnly|QFile::Truncate|QFile::Text))
    {
        return false;
    }

    QTextStream stream(&file);

    stream << "[Pattern]" << endl;
    stream << "pattern = " << _regexp->pattern() << endl;
    stream << "patternSyntax = " << patternSyntaxIdToString(_regexp->patternSyntax()) << endl;
    stream << "caretMode = " << caretModeIdToString(_caretMode) << endl;
    stream << "caseSensitivity = " << BOOL_TO_STRING(_regexp->caseSensitivity()) << endl;
    stream << "minimal = " << BOOL_TO_STRING(_regexp->isMinimal()) << endl;

    file.close();

    _filename = filename;

    return true;
}
Beispiel #2
0
static void LogUnboxed(int log_level,
                void const * const fieldData,
                ProtobufCFieldDescriptor const * const fieldDesc,
                size_t const i,
                char* log_indent)
{
    switch (fieldDesc->type) {
    case PROTOBUF_C_TYPE_INT32:
    case PROTOBUF_C_TYPE_SINT32:
    case PROTOBUF_C_TYPE_SFIXED32:
        {
            int32_t const * value = (int32_t const *)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %ld", log_indent, fieldDesc->name, value[i]);
        }
        break;

    case PROTOBUF_C_TYPE_INT64:
    case PROTOBUF_C_TYPE_SINT64:
    case PROTOBUF_C_TYPE_SFIXED64:
        {
            int64_t* value = (int64_t*)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %lld", log_indent, fieldDesc->name, value[i]);
        }
        break;

    case PROTOBUF_C_TYPE_UINT32:
    case PROTOBUF_C_TYPE_FIXED32:
        {
            uint32_t* value = (uint32_t*)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %lu", log_indent, fieldDesc->name, value[i]);
        }
        break;

    case PROTOBUF_C_TYPE_UINT64:
    case PROTOBUF_C_TYPE_FIXED64:
        {
            uint64_t* value = (uint64_t*)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %llu", log_indent, fieldDesc->name, value[i]);
        }
        break;

    case PROTOBUF_C_TYPE_FLOAT:
        {
            float* value = (float*)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %f", log_indent, fieldDesc->name, value[i]);
        }
        break;

    case PROTOBUF_C_TYPE_DOUBLE:
        {
            double* value = (double*)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %f", log_indent, fieldDesc->name, value[i]);
        }
        break;

    case PROTOBUF_C_TYPE_BOOL:
        {
            protobuf_c_boolean* value = (protobuf_c_boolean*)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %s", log_indent, fieldDesc->name, BOOL_TO_STRING(value[i]));
        }
        break;

    case PROTOBUF_C_TYPE_STRING:
        {
            char** strings = (char**)fieldData;
            KineticLogger_LogPrintf(log_level, "%s%s: %s", log_indent, fieldDesc->name, strings[i]);
        }
        break;

    case PROTOBUF_C_TYPE_BYTES:
        {
            ProtobufCBinaryData* value = (ProtobufCBinaryData*)fieldData;
            log_proto_level_start(fieldDesc->name);
            KineticLogger_LogByteArray(log_level, log_indent,
                                       (ByteArray){.data = value[i].data,
                                                   .len = value[i].len});
            log_proto_level_end();
        }
        break;

    case PROTOBUF_C_TYPE_ENUM:
        {
            int * value = (int*)fieldData;
            ProtobufCEnumDescriptor const * enumDesc = fieldDesc->descriptor;
            ProtobufCEnumValue const * enumVal = protobuf_c_enum_descriptor_get_value(enumDesc, value[i]);
            KineticLogger_LogPrintf(log_level, "%s%s: %s", log_indent, fieldDesc->name, enumVal->name);
        }
        break;

    case PROTOBUF_C_TYPE_MESSAGE:  // nested message
        {
            ProtobufCMessage** msg = (ProtobufCMessage**)fieldData;
            if (msg[i] != NULL)
            {
                log_proto_level_start(fieldDesc->name);
                log_protobuf_message(log_level, msg[i], log_indent);
                log_proto_level_end();
            }
        } break;

    default:
        KineticLogger_LogPrintf(log_level, "Invalid message field type!: %d", fieldDesc->type);
        KINETIC_ASSERT(false); // should never get here!
        break;
    };