souffle::ReadStream Class Reference

#include <ReadStream.h>

Inheritance diagram for souffle::ReadStream:

Collaboration diagram for souffle::ReadStream:

Public Member Functions
template<typename T >
void	readAll (T &relation)
Public Member Functions inherited from souffle::SerialisationStream< false >
virtual	~SerialisationStream ()=default

Protected Member Functions
void	consumeChar (const std::string &str, char c, size_t &pos)
	Read past given character, consuming any preceding whitespace. More...
void	consumeWhiteSpace (const std::string &str, size_t &pos)
	Advance position in the string until first non-whitespace character. More...
RamDomain	readADT (const std::string &source, const std::string &adtName, size_t pos=0, size_t *charactersRead=nullptr)
std::string	readAlphanumeric (const std::string &source, size_t &pos)
	Read the next alphanumeric sequence (corresponding to IDENT). More...
virtual Own< RamDomain[]>	readNextTuple ()=0
RamDomain	readRecord (const std::string &source, const std::string &recordTypeName, size_t pos=0, size_t *charactersRead=nullptr)
	Read a record from a string. More...
	ReadStream (const std::map< std::string, std::string > &rwOperation, SymbolTable &symTab, RecordTable &recTab)
std::string	readUntil (const std::string &source, const std::string stopChars, const size_t pos, size_t *charactersRead)
Protected Member Functions inherited from souffle::SerialisationStream< false >
	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)

Additional Inherited Members
Protected Types inherited from souffle::SerialisationStream< false >
using	RO = std::conditional_t< readOnlyTables, const A, A >
Protected Attributes inherited from souffle::SerialisationStream< false >
size_t	arity
size_t	auxiliaryArity
RO< RecordTable > &	recordTable
RO< SymbolTable > &	symbolTable
std::vector< std::string >	typeAttributes
Json	types

Detailed Description

Definition at line 40 of file ReadStream.h.

Constructor & Destructor Documentation

ReadStream()

souffle::ReadStream::ReadStream ( const std::map< std::string, std::string > &  rwOperation, SymbolTable &  symTab, RecordTable &  recTab  )

inlineprotected

Definition at line 46 of file ReadStream.h.

                                                  {
            const RamDomain* ramDomain = next.get();

References relation.

Member Function Documentation

consumeChar()

void souffle::ReadStream::consumeChar ( const std::string &  str, char  c, size_t &  pos  )

inlineprotected

Read past given character, consuming any preceding whitespace.

Definition at line 290 of file ReadStream.h.

                                                              {
        while (pos < str.length() && std::isspace(static_cast<unsigned char>(str[pos]))) {
            ++pos;
        }

consumeWhiteSpace()

void souffle::ReadStream::consumeWhiteSpace ( const std::string &  str, size_t &  pos  )

inlineprotected

Advance position in the string until first non-whitespace character.

Definition at line 306 of file ReadStream.h.

                        {
public:
    virtual Own<ReadStream> getReader(
            const std::map<std::string, std::string>&, SymbolTable&, RecordTable&) = 0;

References souffle::ReadStreamFactory::getReader().

Here is the call graph for this function:

readADT()

RamDomain souffle::ReadStream::readADT ( const std::string &  source, const std::string &  adtName, size_t  pos = 0, size_t *  charactersRead = nullptr  )

inlineprotected

Definition at line 143 of file ReadStream.h.

                                                       {
            throw std::invalid_argument("Missing ADT information: " + adtName);
        }
 
        // Consume initial character
        consumeChar(source, '$', pos);
        std::string constructor = readAlphanumeric(source, pos);
 
        json11::Json branchInfo = [&]() -> json11::Json {
            for (auto branch : branches.array_items()) {
                ++branchIdx;
                if (branch["name"].string_value() == constructor) {
                    return branch;
                }
            }
 
            throw std::invalid_argument("Missing branch information: " + constructor);
        }();
 
        assert(branchInfo["types"].is_array());
        auto branchTypes = branchInfo["types"].array_items();
 
        // Handle a branch without arguments.
        if (branchTypes.empty()) {
            if (charactersRead != nullptr) {
                *charactersRead = pos - initial_position;
            }
 
            if (adtInfo["enum"].bool_value()) {
                return branchIdx;
            }
 
            RamDomain emptyArgs = recordTable.pack(toVector<RamDomain>().data(), 0);
            return recordTable.pack(toVector<RamDomain>(branchIdx, emptyArgs).data(), 2);
        }
 
        consumeChar(source, '(', pos);
 
        std::vector<RamDomain> branchArgs(branchTypes.size());
 
        for (size_t i = 0; i < branchTypes.size(); ++i) {
            auto argType = branchTypes[i].string_value();
            assert(!argType.empty());
 
            size_t consumed = 0;
 
            if (i > 0) {
                consumeChar(source, ',', pos);
            }
            consumeWhiteSpace(source, pos);
 
            switch (argType[0]) {
                case 's': {
                    branchArgs[i] = symbolTable.unsafeLookup(readUntil(source, ",)", pos, &consumed));
                    break;
                }
                case 'i': {
                    branchArgs[i] = RamSignedFromString(source.substr(pos), &consumed);
                    break;
                }
                case 'u': {
                    branchArgs[i] = ramBitCast(RamUnsignedFromString(source.substr(pos), &consumed));
                    break;
                }
                case 'f': {
                    branchArgs[i] = ramBitCast(RamFloatFromString(source.substr(pos), &consumed));
                    break;
                }
                case 'r': {
                    branchArgs[i] = readRecord(source, argType, pos, &consumed);
                    break;
                }
                case '+': {
                    branchArgs[i] = readADT(source, argType, pos, &consumed);
                    break;
                }
                default: fatal("Invalid type attribute");
            }
            pos += consumed;
        }
 
        consumeChar(source, ')', pos);
 
        if (charactersRead != nullptr) {
            *charactersRead = pos - initial_position;
        }
 
        // Store branch either as [branch_id, [arguments]] or [branch_id, argument].
        RamDomain branchValue = [&]() -> RamDomain {
            if (branchArgs.size() != 1) {
                return recordTable.pack(branchArgs.data(), branchArgs.size());
            } else {
                return branchArgs[0];
            }
        }();
 
        return recordTable.pack(toVector<RamDomain>(branchIdx, branchValue).data(), 2);
    }
 
    /**
     * Read the next alphanumeric sequence (corresponding to IDENT).
     * Consume preceding whitespace.
     * TODO (darth_tytus): use std::string_view?
     */
    std::string readAlphanumeric(const std::string& source, size_t& pos) {
        consumeWhiteSpace(source, pos);

readAll()

template<typename T >

void souffle::ReadStream::readAll ( T &  relation )

inline

Definition at line 52 of file ReadStream.h.

         :
    /**
     * Read a record from a string.
     *
     * @param source - string containing a record
     * @param recordTypeName - record type.
     * @parem pos - start parsing from this position.

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

readAlphanumeric()

std::string souffle::ReadStream::readAlphanumeric ( const std::string &  source, size_t &  pos  )

inlineprotected

Read the next alphanumeric sequence (corresponding to IDENT).

Consume preceding whitespace. TODO (darth_tytus): use std::string_view?

Definition at line 260 of file ReadStream.h.

                                    {
        size_t endOfSymbol = source.find_first_of(stopChars, pos);
 
        if (endOfSymbol == std::string::npos) {
            throw std::invalid_argument("Unexpected end of input");
        }

readNextTuple()

virtual Own<RamDomain[]> souffle::ReadStream::readNextTuple ( )

protectedpure virtual

Implemented in souffle::ReadFileCSV, souffle::ReadStreamCSV, souffle::ReadStreamJSON, and souffle::ReadStreamSQLite.

readRecord()

RamDomain souffle::ReadStream::readRecord ( const std::string &  source, const std::string &  recordTypeName, size_t  pos = 0, size_t *  charactersRead = nullptr  )

inlineprotected

Read a record from a string.

Parameters

source	- string containing a record
recordTypeName	- record type. @parem pos - start parsing from this position.
consumed	- if not nullptr: number of characters read.

Definition at line 71 of file ReadStream.h.

                                            {
            if (charactersRead != nullptr) {
                *charactersRead = 3;
            }
            return 0;
        }
 
        auto&& recordTypes = recordInfo["types"];
        const size_t recordArity = recordInfo["arity"].long_value();
 
        std::vector<RamDomain> recordValues(recordArity);
 
        consumeChar(source, '[', pos);
 
        for (size_t i = 0; i < recordArity; ++i) {
            const std::string& recordType = recordTypes[i].string_value();
            size_t consumed = 0;
 
            if (i > 0) {
                consumeChar(source, ',', pos);
            }
            consumeWhiteSpace(source, pos);
            switch (recordType[0]) {
                case 's': {
                    recordValues[i] = symbolTable.unsafeLookup(readUntil(source, ",]", pos, &consumed));
                    break;
                }
                case 'i': {
                    recordValues[i] = RamSignedFromString(source.substr(pos), &consumed);
                    break;
                }
                case 'u': {
                    recordValues[i] = ramBitCast(RamUnsignedFromString(source.substr(pos), &consumed));
                    break;
                }
                case 'f': {
                    recordValues[i] = ramBitCast(RamFloatFromString(source.substr(pos), &consumed));
                    break;
                }
                case 'r': {
                    recordValues[i] = readRecord(source, recordType, pos, &consumed);
                    break;
                }
                case '+': {
                    recordValues[i] = readADT(source, recordType, pos, &consumed);
                    break;
                }
                default: fatal("Invalid type attribute");
            }
            pos += consumed;
        }
        consumeChar(source, ']', pos);
 
        if (charactersRead != nullptr) {
            *charactersRead = pos - initial_position;
        }
 
        return recordTable.pack(recordValues.data(), recordValues.size());
    }
 
    RamDomain readADT(const std::string& source, const std::string& adtName, size_t pos = 0,
            size_t* charactersRead = nullptr) {
        const size_t initial_position = pos;
 
        // Branch will are encoded as one of the:
        // [branchIdx, [branchValues...]]
        // [branchIdx, branchValue]

readUntil()

std::string souffle::ReadStream::readUntil ( const std::string &  source, const std::string  stopChars, const size_t  pos, size_t *  charactersRead  )

inlineprotected

Definition at line 274 of file ReadStream.h.

                                                                {
        consumeWhiteSpace(str, pos);
        if (pos >= str.length()) {
            throw std::invalid_argument("Unexpected end of input");

---

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

• include/souffle/io/ReadStream.h