souffle::ReadStreamJSON Class Reference

#include <ReadStreamJSON.h>

Inheritance diagram for souffle::ReadStreamJSON:

Collaboration diagram for souffle::ReadStreamJSON:

Public Member Functions
	ReadStreamJSON (std::istream &file, const std::map< std::string, std::string > &rwOperation, SymbolTable &symbolTable, RecordTable &recordTable)
Public Member Functions inherited from souffle::ReadStream
template<typename T >
void	readAll (T &relation)
Public Member Functions inherited from souffle::SerialisationStream< false >
virtual	~SerialisationStream ()=default

Protected Member Functions
RamDomain	readNextElementList (const Json &source, const std::string &recordTypeName)
RamDomain	readNextElementObject (const Json &source, const std::string &recordTypeName)
Own< RamDomain[]>	readNextTuple () override
Own< RamDomain[]>	readNextTupleList ()
Own< RamDomain[]>	readNextTupleObject ()
Protected Member Functions inherited from souffle::ReadStream
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...
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)

Protected Attributes
std::istream &	file
bool	isInitialized
Json	jsonSource
std::map< const std::string, const size_t >	paramIndex
Json	params
size_t	pos
bool	useObjects
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

Additional Inherited Members
Protected Types inherited from souffle::SerialisationStream< false >
using	RO = std::conditional_t< readOnlyTables, const A, A >

Detailed Description

Definition at line 46 of file ReadStreamJSON.h.

Constructor & Destructor Documentation

ReadStreamJSON()

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

inline

Definition at line 48 of file ReadStreamJSON.h.

                              {
            fatal("cannot get internal params: %s", err);
        }
    }
 
protected:
    std::istream& file;
    size_t pos;

Member Function Documentation

readNextElementList()

RamDomain souffle::ReadStreamJSON::readNextElementList ( const Json &  source, const std::string &  recordTypeName  )

inlineprotected

Definition at line 153 of file ReadStreamJSON.h.

                                                                      : " + recordTypeName);
        }
 
        // Handle null case
        if (source.is_null()) {
            return 0;
        }
 
        assert(source.is_array() && "the input is not json array");
        auto&& recordTypes = recordInfo["types"];
        const size_t recordArity = recordInfo["arity"].long_value();
        std::vector<RamDomain> recordValues(recordArity);
        for (size_t i = 0; i < recordArity; ++i) {
            const std::string& recordType = recordTypes[i].string_value();
            switch (recordType[0]) {
                case 's': {
                    recordValues[i] = symbolTable.unsafeLookup(source[i].string_value());
                    break;
                }
                case 'r': {
                    recordValues[i] = readNextElementList(source[i], recordType);
                    break;
                }
                case 'i': {
                    recordValues[i] = source[i].int_value();
                    break;
                }
                case 'u': {
                    recordValues[i] = source[i].int_value();
                    break;
                }
                case 'f': {
                    recordValues[i] = static_cast<RamDomain>(source[i].number_value());
                    break;
                }
                default: fatal("invalid type attribute");
            }
        }
 
        return recordTable.pack(recordValues.data(), recordValues.size());
    }
 
    Own<RamDomain[]> readNextTupleObject() {
        if (pos >= jsonSource.array_items().size()) {
            return nullptr;

readNextElementObject()

RamDomain souffle::ReadStreamJSON::readNextElementObject ( const Json &  source, const std::string &  recordTypeName  )

inlineprotected

Definition at line 249 of file ReadStreamJSON.h.

                        : params["records"][recordName]["params"].array_items()) {
            recordIndex.insert(std::make_pair(param.string_value(), index_pos));
            index_pos++;
        }
 
        if (recordInfo.is_null()) {
            throw std::invalid_argument("Missing record type information: " + recordTypeName);
        }
 
        // Handle null case
        if (source.is_null()) {
            return 0;
        }
 
        assert(source.is_object() && "the input is not json object");
        auto&& recordTypes = recordInfo["types"];
        const size_t recordArity = recordInfo["arity"].long_value();
        std::vector<RamDomain> recordValues(recordArity);
        recordValues.reserve(recordIndex.size());
        for (auto readParam : source.object_items()) {
            // get the corresponding position by parameter name
            if (recordIndex.find(readParam.first) == recordIndex.end()) {
                fatal("invalid parameter: %s", readParam.first);
            }
            size_t i = recordIndex.at(readParam.first);
            auto&& type = recordTypes[i].string_value();
            switch (type[0]) {
                case 's': {
                    recordValues[i] = symbolTable.unsafeLookup(readParam.second.string_value());
                    break;
                }
                case 'r': {
                    recordValues[i] = readNextElementObject(readParam.second, type);
                    break;
                }
                case 'i': {
                    recordValues[i] = readParam.second.int_value();
                    break;
                }
                case 'u': {
                    recordValues[i] = readParam.second.int_value();
                    break;
                }
                case 'f': {
                    recordValues[i] = static_cast<RamDomain>(readParam.second.number_value());
                    break;
                }
                default: fatal("invalid type attribute: `%c`", type[0]);
            }
        }
 
        return recordTable.pack(recordValues.data(), recordValues.size());
    }
};
 
class ReadFileJSON : public ReadStreamJSON {
public:

readNextTuple()

Own<RamDomain[]> souffle::ReadStreamJSON::readNextTuple ( )

inlineoverrideprotectedvirtual

Implements souffle::ReadStream.

Definition at line 67 of file ReadStreamJSON.h.

                                                                 {});
 
            jsonSource = Json::parse(source, error);
            // it should be wrapped by an extra array
            if (error.length() > 0 || !jsonSource.is_array()) {
                fatal("cannot deserialize json because %s:\n%s", error, source);
            }
 
            // we only check the first one, since there are extra checks
            // in readNextTupleObject/readNextTupleList
            if (jsonSource[0].is_array()) {
                useObjects = false;
            } else if (jsonSource[0].is_object()) {
                useObjects = true;
                size_t index_pos = 0;
                for (auto param : params["relation"]["params"].array_items()) {
                    paramIndex.insert(std::make_pair(param.string_value(), index_pos));
                    index_pos++;
                }
            } else {
                fatal("the input is neither list nor object format");
            }
        }
 
        if (useObjects) {
            return readNextTupleObject();
        } else {
            return readNextTupleList();
        }
    }
 
    Own<RamDomain[]> readNextTupleList() {
        if (pos >= jsonSource.array_items().size()) {
            return nullptr;

readNextTupleList()

Own<RamDomain[]> souffle::ReadStreamJSON::readNextTupleList ( )

inlineprotected

Definition at line 104 of file ReadStreamJSON.h.

                                                           {
            try {
                auto&& ty = typeAttributes.at(i);
                switch (ty[0]) {
                    case 's': {
                        tuple[i] = symbolTable.unsafeLookup(jsonObj[i].string_value());
                        break;
                    }
                    case 'r': {
                        tuple[i] = readNextElementList(jsonObj[i], ty);
                        break;
                    }
                    case 'i': {
                        tuple[i] = jsonObj[i].int_value();
                        break;
                    }
                    case 'u': {
                        tuple[i] = jsonObj[i].int_value();
                        break;
                    }
                    case 'f': {
                        tuple[i] = static_cast<RamDomain>(jsonObj[i].number_value());
                        break;
                    }
                    default: fatal("invalid type attribute: `%c`", ty[0]);
                }
            } catch (...) {
                std::stringstream errorMessage;
                if (jsonObj.is_array() && i < jsonObj.array_items().size()) {
                    errorMessage << "Error converting: " << jsonObj[i].dump();
                } else {
                    errorMessage << "Invalid index: " << i;
                }
                throw std::invalid_argument(errorMessage.str());
            }
        }
 
        return tuple;
    }
 
    RamDomain readNextElementList(const Json& source, const std::string& recordTypeName) {
        auto&& recordInfo = types["records"][recordTypeName];
 

readNextTupleObject()

Own<RamDomain[]> souffle::ReadStreamJSON::readNextTupleObject ( )

inlineprotected

Definition at line 199 of file ReadStreamJSON.h.

                    : jsonObj.object_items()) {
            try {
                // get the corresponding position by parameter name
                if (paramIndex.find(p.first) == paramIndex.end()) {
                    fatal("invalid parameter: %s", p.first);
                }
                size_t i = paramIndex.at(p.first);
                auto&& ty = typeAttributes.at(i);
                switch (ty[0]) {
                    case 's': {
                        tuple[i] = symbolTable.unsafeLookup(p.second.string_value());
                        break;
                    }
                    case 'r': {
                        tuple[i] = readNextElementObject(p.second, ty);
                        break;
                    }
                    case 'i': {
                        tuple[i] = p.second.int_value();
                        break;
                    }
                    case 'u': {
                        tuple[i] = p.second.int_value();
                        break;
                    }
                    case 'f': {
                        tuple[i] = static_cast<RamDomain>(p.second.number_value());
                        break;
                    }
                    default: fatal("invalid type attribute: `%c`", ty[0]);
                }
            } catch (...) {
                std::stringstream errorMessage;
                errorMessage << "Error converting: " << p.second.dump();
                throw std::invalid_argument(errorMessage.str());
            }
        }
 
        return tuple;
    }
 
    RamDomain readNextElementObject(const Json& source, const std::string& recordTypeName) {
        auto&& recordInfo = types["records"][recordTypeName];
        const std::string recordName = recordTypeName.substr(2);

Field Documentation

file

std::istream& souffle::ReadStreamJSON::file

protected

Definition at line 59 of file ReadStreamJSON.h.

isInitialized

bool souffle::ReadStreamJSON::isInitialized

protected

Definition at line 63 of file ReadStreamJSON.h.

jsonSource

Json souffle::ReadStreamJSON::jsonSource

protected

Definition at line 61 of file ReadStreamJSON.h.

paramIndex

std::map<const std::string, const size_t> souffle::ReadStreamJSON::paramIndex

protected

Definition at line 65 of file ReadStreamJSON.h.

params

Json souffle::ReadStreamJSON::params

protected

Definition at line 62 of file ReadStreamJSON.h.

pos

size_t souffle::ReadStreamJSON::pos

protected

Definition at line 60 of file ReadStreamJSON.h.

useObjects

bool souffle::ReadStreamJSON::useObjects

protected

Definition at line 64 of file ReadStreamJSON.h.

---

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

• include/souffle/io/ReadStreamJSON.h