bob/libscio
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Removed libscio.hpp, will be auto-generated

Browse Source
This commit is contained in:
Bob Polis 2022-12-14 16:57:27 +01:00
parent 237277857f
commit 46e5eb7250
1 changed files with 0 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

381
src/libscio.hpp
View File

@ -1,381 +0,0 @@
//
// libscio.hpp
// libscio
//
// Created by Bob Polis at 2020-02-14
// Copyright (c) 2020 SwiftCoder. All rights reserved.
//
#ifndef _libscio_H_
#define _libscio_H_
#include <sys/socket.h>
#include <iostream>
#include <streambuf>
#include <cstdio>
#include <cstdint>
#include <cstdlib>
#include <string>
namespace sc {
namespace io {
class fdiobuf : public std::streambuf {
public:
fdiobuf(int fd) : _fd(fd) {}
fdiobuf() : _fd(-1) {}
int fd() const { return _fd; }
void fd(int fd) { _fd = fd; }
protected:
int _fd;
char _ch {};
// input
int_type underflow() override;
std::streamsize xsgetn(char* s, std::streamsize n) override;
// output
int_type overflow(int_type c) override;
std::streamsize xsputn(const char* s, std::streamsize num) override;
// stream offset positioning
pos_type seekoff(off_type off,
std::ios_base::seekdir dir,
std::ios_base::openmode which
= std::ios_base::in | std::ios_base::out) override;
pos_type seekpos(pos_type pos, std::ios_base::openmode which
= std::ios_base::in | std::ios_base::out) override;
int_type pbackfail(int_type c = EOF) override;
};
class fdostream : public std::ostream {
public:
fdostream() : std::ostream(&_outbuf), _outbuf(-1) {}
fdostream(int fd) : std::ostream(&_outbuf), _outbuf(fd) {}
// no copying
fdostream(const fdostream&) = delete;
fdostream& operator=(const fdostream&) = delete;
// moving allowed
fdostream(fdostream&& other);
fdostream& operator=(fdostream&& other);
// cleanup: fdostream is RAII class for open file descriptor
virtual ~fdostream();
int fd() const { return _outbuf.fd(); }
void fd(int fd) { _outbuf.fd(fd); }
bool is_open() const { return _outbuf.fd() != -1; }
void close();
protected:
fdiobuf _outbuf;
};
class fdistream : public std::istream {
public:
fdistream() : std::istream(&_inbuf), _inbuf(-1) {}
fdistream(int fd) : std::istream(&_inbuf), _inbuf(fd) {}
// no copying
fdistream(const fdistream&) = delete;
fdistream& operator=(const fdistream&) = delete;
// moving allowed
fdistream(fdistream&& other);
fdistream& operator=(fdistream&& other);
// cleanup: fdistream is RAII class for open file descriptor
virtual ~fdistream();
int fd() const { return _inbuf.fd(); }
void fd(int fd) { _inbuf.fd(fd); }
bool is_open() const { return _inbuf.fd() != -1; }
void close();
protected:
fdiobuf _inbuf;
};
class fdstream : public std::iostream {
public:
fdstream() : std::iostream(&_iobuf) {}
fdstream(int fd) : std::iostream(&_iobuf), _iobuf(fd) {}
// no copying
fdstream(const fdstream&) = delete;
fdstream& operator=(const fdstream&) = delete;
// moving allowed
fdstream(fdstream&& other);
fdstream& operator=(fdstream&& other);
// cleanup: fdstream is RAII class for open file descriptor
virtual ~fdstream();
int fd() const { return _iobuf.fd(); }
void fd(int fd) { _iobuf.fd(fd); }
bool is_open() const { return _iobuf.fd() != -1; }
void close();
protected:
fdiobuf _iobuf {-1};
};
struct socket_address {
std::string address;
int port;
};
class socketstream : public std::iostream {
public:
socketstream();
socketstream(int domain, int type);
// copying forbidden
socketstream(const socketstream&) = delete;
socketstream& operator=(const socketstream&) = delete;
// moving allowed
socketstream(socketstream&& other);
socketstream& operator=(socketstream&& other);
// cleanup: socketstream is RAII class for open socket
virtual ~socketstream();
bool is_open() { return _iobuf.fd() != -1; }
void close();
// server
void make_server(const socket_address& sa);
socketstream accept() const;
// client
void connect(const socket_address& host);
// convenience: human-readable addresses
std::string address() const;
// address/endpoint conversion methods
void endpoint_from_address(const socket_address& address,
struct sockaddr_storage* endpoint) const;
socket_address address_from_endpoint(const struct sockaddr* endpoint) const;
// getters & setters
int socket() const { return _iobuf.fd(); }
void socket(int sock) { _iobuf.fd(sock); }
int domain() const { return _domain; }
void domain(int dom) { _domain = dom; }
int type() const { return _type; }
void type(int typ) { _type = typ; }
protected:
fdiobuf _iobuf {-1};
int _domain {0};
int _type {0};
struct sockaddr_storage _sa;
};
struct float_80 {
unsigned char _val[10]; // big endian
float_80();
float_80(double val);
operator double() const;
};
enum class byte_order {
undefined,
little_endian,
big_endian
};
class data_streamer {
public:
static byte_order cur_byte_order();
static inline void byte_swap(void* val, size_t n) {
char* p = reinterpret_cast<char*>(val);
for (size_t i = 0; i < n / 2; ++i) {
std::swap(p[i], p[n - 1 - i]);
}
}
template<class T>
inline T get(std::istream& file) const {
char buf[sizeof(T)];
file.read(buf, sizeof(T));
if (cur_byte_order() != _target_byte_order) {
byte_swap(buf, sizeof(T));
}
return *reinterpret_cast<T*>(buf);
}
template<class T>
inline void put(T val, std::ostream& file) const {
if (cur_byte_order() != _target_byte_order) {
byte_swap(&val, sizeof(T));
}
file.write(reinterpret_cast<char*>(&val), sizeof(T));
}
data_streamer() = default;
data_streamer(byte_order bo);
byte_order target_byte_order() const { return _target_byte_order; }
void target_byte_order(byte_order new_byte_order) { _target_byte_order = new_byte_order; }
std::string get4chars(std::istream& file) const;
uint8_t getui8(std::istream& file) const { return static_cast<uint8_t>(file.get()); }
int8_t getsi8(std::istream& file) const { return file.get(); }
uint16_t getui16(std::istream& file) const { return get<uint16_t>(file); }
int16_t getsi16(std::istream& file) const { return get<int16_t>(file); }
uint32_t getui24(std::istream& file) const;
int32_t getsi24(std::istream& file) const;
uint32_t getui32(std::istream& file) const { return get<uint32_t>(file); }
int32_t getsi32(std::istream& file) const { return get<int32_t>(file); }
uint64_t getui64(std::istream& file) const { return get<uint64_t>(file); }
int64_t getsi64(std::istream& file) const { return get<int64_t>(file); }
float getf32(std::istream& file) const { return get<float>(file); }
double getf64(std::istream& file) const { return get<double>(file); }
double getf80(std::istream& file) const;
void put4chars(const std::string& s, std::ostream& file) const;
void putui8(uint8_t val, std::ostream& file) const { file.put(val); }
void putsi8(int8_t val, std::ostream& file) const { file.put(val); }
void putui16(uint16_t val, std::ostream& file) const { put<uint16_t>(val, file); }
void putsi16(int16_t val, std::ostream& file) const { put<int16_t>(val, file); }
void putui24(uint32_t val, std::ostream& file) const;
void putsi24(int32_t val, std::ostream& file) const;
void putui32(uint32_t val, std::ostream& file) const { put<uint32_t>(val, file); }
void putsi32(int32_t val, std::ostream& file) const { put<int32_t>(val, file); }
void putui64(uint64_t val, std::ostream& file) const { put<uint64_t>(val, file); }
void putsi64(int64_t val, std::ostream& file) const { put<int64_t>(val, file); }
void putf32(float val, std::ostream& file) const { put<float>(val, file); }
void putf64(double val, std::ostream& file) const { put<double>(val, file); }
void putf80(double val, std::ostream& file) const;
private:
byte_order _target_byte_order {cur_byte_order()};
};
class byte_order_changer {
public:
byte_order_changer(data_streamer* ds, byte_order order);
~byte_order_changer();
byte_order_changer(byte_order_changer&& other);
byte_order_changer& operator=(byte_order_changer&& other);
byte_order_changer(const byte_order_changer&) = delete;
byte_order_changer& operator=(const byte_order_changer&) = delete;
private:
data_streamer* _data_streamer {nullptr};
byte_order _saved_byte_order {byte_order::undefined};
};
class mapped_file {
public:
mapped_file() = default;
mapped_file(const std::string& path);
// no copying
mapped_file(const mapped_file&) = delete;
mapped_file& operator=(const mapped_file&) = delete;
// moving allowed
mapped_file(mapped_file&& other);
mapped_file& operator=(mapped_file&& other);
// cleanup: mapped_file is RAII class for memory mapping and file descriptor
~mapped_file();
// it's an error to open an already opened mapped_file
// open() is meant to be used after default constructor
void open(const std::string& path);
bool is_open() const { return _fd != -1; }
// direct (read-only) access to mapped memory
char* mapping() const { return _mapping; }
size_t size() const { return _length; }
private:
int _fd {-1};
char* _mapping {nullptr};
size_t _length {0};
};
class memstreambuf : public std::streambuf {
public:
memstreambuf() = default;
void init(char* mem, size_t size);
memstreambuf(char* mem, size_t size);
void mem(char* m) { _mem = m; }
char* mem() const { return _mem; }
void size(size_t sz) { _size = sz; }
size_t size() const { return _size; }
protected:
// input
int_type underflow() override;
int_type uflow() override;
// output
int_type overflow(int_type c) override;
std::streamsize xsputn(const char* s, std::streamsize num) override;
// stream offset positioning
pos_type seekoff(off_type off,
std::ios_base::seekdir dir,
std::ios_base::openmode which
= std::ios_base::in | std::ios_base::out) override;
pos_type seekpos(pos_type pos, std::ios_base::openmode which
= std::ios_base::in | std::ios_base::out) override;
int_type pbackfail(int_type c = EOF) override;
private:
char* _mem {nullptr};
size_t _size {0};
};
class imemfile : public std::istream {
public:
imemfile() : std::istream(&_buf) {}
imemfile(const std::string& path);
// no copying
imemfile(const imemfile&) = delete;
imemfile& operator=(const imemfile&) = delete;
// move is allowed
imemfile(imemfile&& other);
imemfile& operator=(imemfile&&) = default;
~imemfile() = default;
bool is_open() const { return _file.is_open(); }
void open(const std::string& path, std::ios_base::openmode mode
= std::ios_base::in | std::ios_base::binary);
char* data() const { return _file.mapping(); }
size_t size() const { return _file.size(); }
private:
mapped_file _file;
memstreambuf _buf;
};
}
}
#endif // _libscio_H_