#include "binaryninjaapi.h"

using namespace BinaryNinja;

using namespace std;

BinaryWriter::BinaryWriter(BinaryView* data, BNEndianness endian) : m_view(data)

}

BinaryWriter::~BinaryWriter()

{

BNFreeBinaryWriter(m_stream);

}

BNEndianness BinaryWriter::GetEndianness() const

{

return BNGetBinaryWriterEndianness(m_stream);

}

void BinaryWriter::SetEndianness(BNEndianness endian)

{

BNSetBinaryWriterEndianness(m_stream, endian);

}

void BinaryWriter::Write(const void* src, size_t len)

}

void BinaryWriter::Write(const DataBuffer& buf)

{

Write(buf.GetData(), buf.GetLength());

}

void BinaryWriter::Write(const string& str)

{

Write(str.c_str(), str.size());

}

void BinaryWriter::Write8(uint8_t val)

}

void BinaryWriter::Write16(uint16_t val)

}

void BinaryWriter::Write32(uint32_t val)

}

void BinaryWriter::Write64(uint64_t val)

}

void BinaryWriter::WriteLE16(uint16_t val)

}

void BinaryWriter::WriteLE32(uint32_t val)

}

void BinaryWriter::WriteLE64(uint64_t val)

}

void BinaryWriter::WriteBE16(uint16_t val)

}

void BinaryWriter::WriteBE32(uint32_t val)

}

void BinaryWriter::WriteBE64(uint64_t val)

}

bool BinaryWriter::TryWrite(const void* src, size_t len)

{

return BNWriteData(m_stream, src, len);

}

bool BinaryWriter::TryWrite(const DataBuffer& buf)

{

return TryWrite(buf.GetData(), buf.GetLength());

}

bool BinaryWriter::TryWrite(const string& str)

{

return TryWrite(str.c_str(), str.size());

}

bool BinaryWriter::TryWrite8(uint8_t val)

{

return BNWrite8(m_stream, val);

}

bool BinaryWriter::TryWrite16(uint16_t val)

{

return BNWrite16(m_stream, val);

}

bool BinaryWriter::TryWrite32(uint32_t val)

{

return BNWrite32(m_stream, val);

}

bool BinaryWriter::TryWrite64(uint64_t val)

{

return BNWrite64(m_stream, val);

}

bool BinaryWriter::TryWriteLE16(uint16_t val)

{

return BNWriteLE16(m_stream, val);

}

bool BinaryWriter::TryWriteLE32(uint32_t val)

{

return BNWriteLE32(m_stream, val);

}

bool BinaryWriter::TryWriteLE64(uint64_t val)

{

return BNWriteLE64(m_stream, val);

}

bool BinaryWriter::TryWriteBE16(uint16_t val)

{

return BNWriteBE16(m_stream, val);

}

bool BinaryWriter::TryWriteBE32(uint32_t val)

{

return BNWriteBE32(m_stream, val);

}

bool BinaryWriter::TryWriteBE64(uint64_t val)

{

return BNWriteBE64(m_stream, val);

}

uint64_t BinaryWriter::GetOffset() const

{

return BNGetWriterPosition(m_stream);

}

void BinaryWriter::Seek(uint64_t offset)

{

BNSeekBinaryWriter(m_stream, offset);

}

void BinaryWriter::SeekRelative(int64_t offset)

{

BNSeekBinaryWriterRelative(m_stream, offset);

}