souffle::WriteStreamJSON Class Reference

#include <WriteStreamJSON.h>

Inheritance diagram for souffle::WriteStreamJSON:

Collaboration diagram for souffle::WriteStreamJSON:

Protected Member Functions
void	writeNextTupleJSON (std::ostream &destination, const RamDomain *tuple)
void	writeNextTupleList (std::ostream &destination, const std::string &name, const RamDomain value)
void	writeNextTupleObject (std::ostream &destination, const std::string &name, const RamDomain value)
	WriteStreamJSON (const std::map< std::string, std::string > &rwOperation, const SymbolTable &symbolTable, const RecordTable &recordTable)
Protected Member Functions inherited from souffle::WriteStream
void	outputADT (std::ostream &destination, const RamDomain value, const std::string &name)
void	outputRecord (std::ostream &destination, const RamDomain value, const std::string &name)
template<typename Tuple >
void	writeNext (const Tuple tuple)
virtual void	writeNextTuple (const RamDomain *tuple)=0
virtual void	writeNullary ()=0
virtual void	writeSize (std::size_t)
Protected Member Functions inherited from souffle::SerialisationStream< true >
	SerialisationStream (RO< SymbolTable > &symTab, RO< RecordTable > &recTab, const std::map< std::string, std::string > &rwOperation)
	SerialisationStream (RO< SymbolTable > &symTab, RO< RecordTable > &recTab, Json types)
	SerialisationStream (RO< SymbolTable > &symTab, RO< RecordTable > &recTab, Json types, std::vector< std::string > relTypes, size_t auxArity=0)

Protected Attributes
Json	params
const bool	useObjects
Protected Attributes inherited from souffle::WriteStream
const bool	summary
Protected Attributes inherited from souffle::SerialisationStream< true >
size_t	arity
size_t	auxiliaryArity
RO< RecordTable > &	recordTable
RO< SymbolTable > &	symbolTable
std::vector< std::string >	typeAttributes
Json	types

Additional Inherited Members
Public Member Functions inherited from souffle::WriteStream
template<typename T >
void	writeAll (const T &relation)
template<>
void	writeNext (const RamDomain *tuple)
template<typename T >
void	writeSize (const T &relation)
	WriteStream (const std::map< std::string, std::string > &rwOperation, const SymbolTable &symbolTable, const RecordTable &recordTable)
Public Member Functions inherited from souffle::SerialisationStream< true >
virtual	~SerialisationStream ()=default
Protected Types inherited from souffle::SerialisationStream< true >
using	RO = std::conditional_t< readOnlyTables, const A, A >

Detailed Description

Definition at line 37 of file WriteStreamJSON.h.

Constructor & Destructor Documentation

WriteStreamJSON()

souffle::WriteStreamJSON::WriteStreamJSON ( const std::map< std::string, std::string > &  rwOperation, const SymbolTable &  symbolTable, const RecordTable &  recordTable  )

inlineprotected

Definition at line 43 of file WriteStreamJSON.h.

                                                      : %s", err);
            }
        }
    };
 
    const bool useObjects;
    Json params;
 
    void writeNextTupleJSON(std::ostream& destination, const RamDomain* tuple) {
        std::vector<Json> result;
 
        if (useObjects)

Member Function Documentation

writeNextTupleJSON()

void souffle::WriteStreamJSON::writeNextTupleJSON ( std::ostream &  destination, const RamDomain *  tuple  )

inlineprotected

Definition at line 59 of file WriteStreamJSON.h.

                                                 {
            if (col > 0) {
                destination << ", ";
            }
 
            if (useObjects) {
                destination << params["relation"]["params"][col].dump() << ": ";
                writeNextTupleObject(destination, typeAttributes.at(col), tuple[col]);
            } else {
                writeNextTupleList(destination, typeAttributes.at(col), tuple[col]);
            }
        }
 
        if (useObjects)
            destination << "}";
        else
            destination << "]";
    }
 
    void writeNextTupleList(std::ostream& destination, const std::string& name, const RamDomain value) {
        using ValueTuple = std::pair<const std::string, const RamDomain>;
        std::stack<std::variant<ValueTuple, std::string>> worklist;
        worklist.push(std::make_pair(name, value));
 
        // the Json11 output is not tail recursive, therefore highly inefficient for recursive record
        // in addition the JSON object is immutable, so has memory overhead

References json11::Json::dump(), params, souffle::SerialisationStream< true >::typeAttributes, useObjects, writeNextTupleList(), and writeNextTupleObject().

Here is the call graph for this function:

writeNextTupleList()

void souffle::WriteStreamJSON::writeNextTupleList ( std::ostream &  destination, const std::string &  name, const RamDomain  value  )

inlineprotected

Definition at line 86 of file WriteStreamJSON.h.

                                                       {
                destination << std::get<std::string>(curr);
                continue;
            }
 
            const std::string& currType = std::get<ValueTuple>(curr).first;
            const RamDomain currValue = std::get<ValueTuple>(curr).second;
            assert(currType.length() > 2 && "Invalid type length");
            switch (currType[0]) {
                // since some strings may need to be escaped, we use dump here
                case 's': destination << Json(symbolTable.unsafeResolve(currValue)).dump(); break;
                case 'i': destination << currValue; break;
                case 'u': destination << (int)ramBitCast<RamUnsigned>(currValue); break;
                case 'f': destination << ramBitCast<RamFloat>(currValue); break;
                case 'r': {
                    auto&& recordInfo = types["records"][currType];
                    assert(!recordInfo.is_null() && "Missing record type information");
                    if (currValue == 0) {
                        destination << "null";
                        break;
                    }
 
                    auto&& recordTypes = recordInfo["types"];
                    const size_t recordArity = recordInfo["arity"].long_value();
                    const RamDomain* tuplePtr = recordTable.unpack(currValue, recordArity);
                    worklist.push("]");
                    for (auto i = (long long)(recordArity - 1); i >= 0; --i) {
                        if (i != (long long)(recordArity - 1)) {
                            worklist.push(", ");
                        }
                        const std::string& recordType = recordTypes[i].string_value();
                        const RamDomain recordValue = tuplePtr[i];
                        worklist.push(std::make_pair(recordType, recordValue));
                    }
 
                    worklist.push("[");
                    break;
                }
                default: fatal("unsupported type attribute: `%c`", currType[0]);
            }
        }
    }
 
    void writeNextTupleObject(std::ostream& destination, const std::string& name, const RamDomain value) {
        using ValueTuple = std::pair<const std::string, const RamDomain>;
        std::stack<std::variant<ValueTuple, std::string>> worklist;
        worklist.push(std::make_pair(name, value));
 
        // the Json11 output is not tail recursive, therefore highly inefficient for recursive record
        // in addition the JSON object is immutable, so has memory overhead

Referenced by writeNextTupleJSON().

writeNextTupleObject()

void souffle::WriteStreamJSON::writeNextTupleObject ( std::ostream &  destination, const std::string &  name, const RamDomain  value  )

inlineprotected

Definition at line 140 of file WriteStreamJSON.h.

                                                       {
                destination << std::get<std::string>(curr);
                continue;
            }
 
            const std::string& currType = std::get<ValueTuple>(curr).first;
            const RamDomain currValue = std::get<ValueTuple>(curr).second;
            const std::string& typeName = currType.substr(2);
            assert(currType.length() > 2 && "Invalid type length");
            switch (currType[0]) {
                // since some strings may need to be escaped, we use dump here
                case 's': destination << Json(symbolTable.unsafeResolve(currValue)).dump(); break;
                case 'i': destination << currValue; break;
                case 'u': destination << (int)ramBitCast<RamUnsigned>(currValue); break;
                case 'f': destination << ramBitCast<RamFloat>(currValue); break;
                case 'r': {
                    auto&& recordInfo = types["records"][currType];
                    assert(!recordInfo.is_null() && "Missing record type information");
                    if (currValue == 0) {
                        destination << "null";
                        break;
                    }
 
                    auto&& recordTypes = recordInfo["types"];
                    const size_t recordArity = recordInfo["arity"].long_value();
                    const RamDomain* tuplePtr = recordTable.unpack(currValue, recordArity);
                    worklist.push("}");
                    for (auto i = (long long)(recordArity - 1); i >= 0; --i) {
                        if (i != (long long)(recordArity - 1)) {
                            worklist.push(", ");
                        }
                        const std::string& recordType = recordTypes[i].string_value();
                        const RamDomain recordValue = tuplePtr[i];
                        worklist.push(std::make_pair(recordType, recordValue));
                        worklist.push(": ");
 
                        auto&& recordParam = params["records"][typeName]["params"][i];
                        assert(recordParam.is_string());
                        worklist.push(recordParam.dump());
                    }
 
                    worklist.push("{");
                    break;
                }
                default: fatal("unsupported type attribute: `%c`", currType[0]);
            }
        }
    }
};
 
class WriteFileJSON : public WriteStreamJSON {
public:
    WriteFileJSON(const std::map<std::string, std::string>& rwOperation, const SymbolTable& symbolTable,
            const RecordTable& recordTable)
            : WriteStreamJSON(rwOperation, symbolTable, recordTable), isFirst(true),
              file(getFileName(rwOperation), std::ios::out | std::ios::binary) {

Referenced by writeNextTupleJSON().

Field Documentation

params

Json souffle::WriteStreamJSON::params

protected

Definition at line 57 of file WriteStreamJSON.h.

Referenced by writeNextTupleJSON().

useObjects

const bool souffle::WriteStreamJSON::useObjects

protected

Definition at line 54 of file WriteStreamJSON.h.

Referenced by writeNextTupleJSON().

---

The documentation for this class was generated from the following file:

• include/souffle/io/WriteStreamJSON.h