Record.hpp

Go to the documentation of this file.

#ifndef COMPLETEDB_RECORD_HPP
#define COMPLETEDB_RECORD_HPP

#include "CompleteDb.h"
#include "common/CompleteDbTypes.hpp"
#include "completedb/Object.hpp"
#include "completedb/Columns.hpp"
#include "completedb/FastStatement.hpp"

namespace completedb {

class Record
:       public virtual Object
,       public Columns
,       public FastStatement
{

        friend class Database;
        friend class Table;
        friend class TableDml;

public: // override Object iface

        inline bool cast(const Object& from) { return completedb_Record_cast(&m, from.get(), from.getClassType()); }
        inline bool isConnected() const { return completedb_Record_isConnected(m); }
        inline bool isDisconnected() const { return completedb_Record_isDisconnected(m); }
        inline Type::Enum getClassType() const { return completedb_Record_getClassType(m); }
        inline Type::Enum getObjectType() const { return completedb_Record_getObjectType(m); }

public: // override Columns iface

        inline ColumnBool getColumnBool(const char* name) { return completedb_Record_getColumnBool(m, name); }
        inline ColumnDouble getColumnDouble(const char* name) { return completedb_Record_getColumnDouble(m, name); }
        inline ColumnFloat getColumnFloat(const char* name) { return completedb_Record_getColumnFloat(m, name); }
        inline ColumnInt16 getColumnInt16(const char* name) { return completedb_Record_getColumnInt16(m, name); }
        inline ColumnInt32 getColumnInt32(const char* name) { return completedb_Record_getColumnInt32(m, name); }
        inline ColumnInt64 getColumnInt64(const char* name) { return completedb_Record_getColumnInt64(m, name); }
        inline ColumnInt8 getColumnInt8(const char* name) { return completedb_Record_getColumnInt8(m, name); }
        inline ColumnString getColumnString(const char* name) { return completedb_Record_getColumnString(m, name); }

public: // override LastError iface

        inline Error::Enum getLastErrorId() const { return completedb_Record_getLastErrorId(m); }
        inline const char* getLastError() const { return completedb_Record_getLastError(m); }

public: // override FastStatement iface

        inline bool prepare() { return completedb_Record_prepare(m); }

public: // iface

        inline bool commitRow() { return completedb_Record_commitRow(m); }
        inline bool commitRow(DirectId& directId) { return completedb_Record_commitRowEx(m, &directId); }
        inline bool copyBuffer() { return completedb_Record_copyBuffer(m); }
        inline bool deleteDirect(const DirectId& directId) { return completedb_Record_deleteDirect(m, &directId); }
        inline bool deleteRow() { return completedb_Record_deleteRow(m); }
        inline bool deleteSurrogate(const SurrogateId& surrogateId) { return completedb_Record_deleteSurrogate(m, &surrogateId); }
        inline bool getDirectId(DirectId& directId) { return completedb_Record_getDirectId(m, &directId); }
        inline bool getSurrogateId(SurrogateId& surrogateId) { return completedb_Record_getSurrogateId(m, &surrogateId); }
        inline bool holdDirect(const DirectId& directId) { return completedb_Record_holdDirect(m, &directId); }
        inline bool holdRow() { return completedb_Record_holdRow(m); }
        inline bool holdSurrogate(const SurrogateId& surrogateId) { return completedb_Record_holdSurrogate(m, &surrogateId); }
        inline bool insertSurrogate(const SurrogateId& surrogateId) { return completedb_Record_insertSurrogate(m, &surrogateId); }
        inline bool loadDirect(const DirectId& directId) { return completedb_Record_loadDirect(m, &directId); }
        inline bool loadDirectOutside(const DirectId& directId) { return completedb_Record_loadDirectOutside(m, &directId); }
        inline bool loadRow() { return completedb_Record_loadRow(m); }
        inline bool loadRowOutside() { return completedb_Record_loadRowOutside(m); }
        inline bool loadSurrogate(const SurrogateId& surrogateId) { return completedb_Record_loadSurrogate(m, &surrogateId); }
        inline bool loadSurrogateOutside(const SurrogateId& surrogateId) { return completedb_Record_loadSurrogateOutside(m, &surrogateId); }
        inline bool nextRow() { return completedb_Record_nextRow(m); }
        inline bool nextRowOutside() { return completedb_Record_nextRowOutside(m); }
        inline bool resetRowIterator() { return completedb_Record_resetRowIterator(m); }
        inline bool rollbackRow() { return completedb_Record_rollbackRow(m); }
        inline uint32_t getBufferSize() const { return completedb_Record_getBufferSize(m); }

public: // factory lvalue

        Record& operator=(const Record& src) { completedb_Record_assign(&m, src.m, src.getClassType()); return *this; }
        Record(const Record& src) : Object(completedb_Record_alloc_copy(src.m, src.getClassType())) {}

public: // factory

        virtual ~Record() { completedb_Record_free(&m); }
        Record() : Object(completedb_Record_alloc()) {}

private: // factory

        Record(void* src) : Object(src) {}

};

} // namespace

#endif /* COMPLETEDB_RECORD_HPP */