リファレンス

Header <hamigaki/binary/binary_io.hpp>

namespace hamigaki {
  template<endianness E, typename T> struct binary_io_traits;

  // binary input functions
  template<typename T> void binary_read(const char*, T&);
  template<endianness E, typename T> void binary_read(const char*, T&);
  template<typename T> T binary_read(const char*);
  template<endianness E, typename T> T binary_read(const char*);

  // binary output functions
  template<typename T> void binary_write(char*, const T&);
  template<endianness E, typename T> void binary_write(char*, const T&);
  template<typename T> void binary_write(std::string&, const T&);
  template<endianness E, typename T> void binary_write(std::string&, const T&);
}

binary input functions

template<typename T> void binary_read(const char* s, T& x);
template<endianness E, typename T> void binary_read(const char* s, T& x);
template<typename T> T binary_read(const char* s);
template<endianness E, typename T> T binary_read(const char* s);

指定したエンディアンでバイナリ入力を行う。

エンディアンEでバイナリ入力を行う。エンディアンの指定がないバージョンはE = nativeの場合と同じである。

Effects:

binary_io_traits<E,T>::read(s, x);

または

T x;
binary_io_traits<E,T>::read(s, x);
return x;

binary output functions

template<typename T> void binary_write(char* s, const T& x);
template<endianness E, typename T> void binary_write(char* s, const T& x);
template<typename T> void binary_write(std::string& s, const T& x);
template<endianness E, typename T> 
  void binary_write(std::string& s, const T& x);

指定したエンディアンでバイナリ出力を行う。

エンディアンEでバイナリ出力を行う。エンディアンの指定がないバージョンはE = nativeの場合と同じである。

Effects:

binary_io_traits<E,T>::write(s, x);

または

char data[binary_size<T>::value];
std::memset(data, 0, sizeof(data));
binary_io_traits<E,T>::write(data, x);
s.append(data, sizeof(data));

Header <hamigaki/binary/endian.hpp>

namespace hamigaki {
  enum endianness;

  template<std::size_t Size> struct integer_encoding_traits;

  // encoding/decoding functions
  template<endianness E, std::size_t Size> 
    void encode_uint(char*, typename integer_encoding_traits<Size>::uint_type);
  template<endianness E, std::size_t Size> 
    void encode_int(char*, typename integer_encoding_traits<Size>::int_type);
  template<endianness E, std::size_t Size> 
    typename integer_encoding_traits<Size>::uint_type decode_uint(const char*);
  template<endianness E, std::size_t Size> 
    typename integer_encoding_traits<Size>::int_type decode_int(const char*);
}

encoding/decoding functions

template<endianness E, std::size_t Size> 
  void encode_uint(char* s, 
                   typename integer_encoding_traits<Size>::uint_type n);

Effects: 符号なし整数nをエンディアンEでエンコードして範囲[s, s+Size)に書き出す。

template<endianness E, std::size_t Size> 
  void encode_int(char* s, typename integer_encoding_traits<Size>::int_type n);

Effects: 符号付き整数nをエンディアンEでエンコードして範囲[s, s+Size)に書き出す。

template<endianness E, std::size_t Size> 
  typename integer_encoding_traits<Size>::uint_type decode_uint(const char* s);

Effects:	範囲`[s, s+Size)`をエンディアン`E`で符号なし整数としてデコードする。
Returns:	デコードされた整数値

template<endianness E, std::size_t Size> 
  typename integer_encoding_traits<Size>::int_type decode_int(const char* s);

Effects:	範囲`[s, s+Size)`をエンディアン`E`で符号付き整数としてデコードする。
Returns:	デコードされた整数値

Header <hamigaki/binary/struct_traits.hpp>

namespace hamigaki {
  template<typename Struct, typename Type, Type Struct::* PtrToMember> 
    struct member_base;
  template<typename Struct, typename Type, Type Struct::* PtrToMember, 
           endianness E = native> 
    struct member;
  template<std::size_t Size> struct padding;
  template<typename T> struct struct_traits;
  template<typename T> struct struct_size;
  template<typename T> struct member_size;
}