souffle::WriteStream Class Reference

#include <WriteStream.h>

Inheritance diagram for souffle::WriteStream:

Collaboration diagram for souffle::WriteStream:

Public Member Functions
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 Member Functions
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
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
Protected Types inherited from souffle::SerialisationStream< true >
using	RO = std::conditional_t< readOnlyTables, const A, A >

Detailed Description

Definition at line 38 of file WriteStream.h.

Constructor & Destructor Documentation

WriteStream()

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

inline

Definition at line 40 of file WriteStream.h.

                                     {
        if (summary) {

References relation, summary, and writeSize().

Referenced by souffle::WriteCoutCSV::writeNextTuple().

Here is the call graph for this function:

Member Function Documentation

outputADT()

void souffle::WriteStream::outputADT ( std::ostream &  destination, const RamDomain  value, const std::string &  name  )

inlineprotected

Definition at line 124 of file WriteStream.h.

                     {
            const RamDomain* tuplePtr = recordTable.unpack(value, 2);
 
            branchId = tuplePtr[0];
            branchInfo = adtInfo["branches"][branchId];
            branchTypes = branchInfo["types"].array_items();
 
            // Prepare branch's arguments for output.
            branchArgs = [&]() -> const RamDomain* {
                if (branchTypes.size() > 1) {
                    return recordTable.unpack(tuplePtr[1], branchTypes.size());
                } else {
                    return &tuplePtr[1];
                }
            }();
        } else {
            branchInfo = adtInfo["branches"][branchId];
            branchTypes = branchInfo["types"].array_items();
        }
 
        destination << "$" << branchInfo["name"].string_value();
 
        if (branchTypes.size() > 0) {
            destination << "(";
        }
 
        // Print arguments
        for (size_t i = 0; i < branchTypes.size(); ++i) {
            if (i > 0) {
                destination << ", ";
            }
 
            auto argType = branchTypes[i].string_value();
            switch (argType[0]) {
                case 'i': destination << branchArgs[i]; break;
                case 'f': destination << ramBitCast<RamFloat>(branchArgs[i]); break;
                case 'u': destination << ramBitCast<RamUnsigned>(branchArgs[i]); break;
                case 's': destination << symbolTable.unsafeResolve(branchArgs[i]); break;
                case 'r': outputRecord(destination, branchArgs[i], argType); break;
                case '+': outputADT(destination, branchArgs[i], argType); break;
                default: fatal("Unsupported type attribute: `%c`", argType[0]);
            }
        }
 
        if (branchTypes.size() > 0) {
            destination << ")";
        }
    }
};
 
class WriteStreamFactory {
public:

outputRecord()

void souffle::WriteStream::outputRecord ( std::ostream &  destination, const RamDomain  value, const std::string &  name  )

inlineprotected

Definition at line 83 of file WriteStream.h.

                        {
            destination << "nil";
            return;
        }
 
        auto&& recordTypes = recordInfo["types"];
        const size_t recordArity = recordInfo["arity"].long_value();
 
        const RamDomain* tuplePtr = recordTable.unpack(value, recordArity);
 
        destination << "[";
 
        // print record's elements
        for (size_t i = 0; i < recordArity; ++i) {
            if (i > 0) {
                destination << ", ";
            }
 
            const std::string& recordType = recordTypes[i].string_value();
            const RamDomain recordValue = tuplePtr[i];
 
            switch (recordType[0]) {
                case 'i': destination << recordValue; break;
                case 'f': destination << ramBitCast<RamFloat>(recordValue); break;
                case 'u': destination << ramBitCast<RamUnsigned>(recordValue); break;
                case 's': destination << symbolTable.unsafeResolve(recordValue); break;
                case 'r': outputRecord(destination, recordValue, recordType); break;
                case '+': outputADT(destination, recordValue, recordType); break;
                default: fatal("Unsupported type attribute: `%c`", recordType[0]);
            }
        }
        destination << "]";
    }
 
    void outputADT(std::ostream& destination, const RamDomain value, const std::string& name) {
        auto&& adtInfo = types["ADTs"][name];
 

writeAll()

template<typename T >

void souffle::WriteStream::writeAll ( const T &  relation )

inline

Definition at line 46 of file WriteStream.h.

                        {
            if (relation.begin() != relation.end()) {
                writeNullary();
            }
            return;
        }
        for (const auto& current : relation) {
            writeNext(current);
        }
    }
 
    template <typename T>
    void writeSize(const T& relation) {
        writeSize(relation.size());

References relation, and writeNullary().

Here is the call graph for this function:

writeNext() [1/2]

template<>

void souffle::WriteStream::writeNext ( const RamDomain *  tuple )

inline

Definition at line 203 of file WriteStream.h.

writeNext() [2/2]

template<typename Tuple >

void souffle::WriteStream::writeNext ( const Tuple  tuple )

inlineprotected

Definition at line 78 of file WriteStream.h.

                                                                                             {
        auto&& recordInfo = types["records"][name];
 

References souffle::SerialisationStream< true >::types.

writeNextTuple()

virtual void souffle::WriteStream::writeNextTuple ( const RamDomain *  tuple )

protectedpure virtual

Implemented in souffle::WriteCoutJSON, souffle::WriteFileJSON, souffle::WriteCoutCSV, souffle::WriteFileCSV, souffle::WriteStreamSQLite, and souffle::WriteCoutPrintSize.

Referenced by writeSize().

writeNullary()

virtual void souffle::WriteStream::writeNullary ( )

protectedpure virtual

Implemented in souffle::WriteCoutJSON, souffle::WriteFileJSON, souffle::WriteCoutPrintSize, souffle::WriteCoutCSV, souffle::WriteFileCSV, and souffle::WriteStreamSQLite.

Referenced by writeAll().

writeSize() [1/2]

template<typename T >

void souffle::WriteStream::writeSize ( const T &  relation )

inline

Definition at line 64 of file WriteStream.h.

         :
    const bool summary;
 

Referenced by WriteStream().

writeSize() [2/2]

virtual void souffle::WriteStream::writeSize ( std::size_t  )

inlineprotectedvirtual

Reimplemented in souffle::WriteCoutPrintSize.

Definition at line 73 of file WriteStream.h.

                                      {
        using tcb::make_span;

References TCB_SPAN_NAMESPACE_NAME::detail::data(), TCB_SPAN_NAMESPACE_NAME::make_span(), and writeNextTuple().

Here is the call graph for this function:

Field Documentation

summary

const bool souffle::WriteStream::summary

protected

Definition at line 69 of file WriteStream.h.

Referenced by WriteStream().

---

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

• include/souffle/io/WriteStream.h