io_buf.h File Reference

#include <sys/types.h>
#include <unistd.h>
#include <cstdio>
#include <fcntl.h>
#include "v_array.h"
#include <iostream>
#include <sstream>
#include <cerrno>
#include <stdexcept>
#include "hash.h"
#include "vw_exception.h"
#include "vw_validate.h"

Go to the source code of this file.

Classes
class	io_buf

Macros
#define	O_LARGEFILE   0
#define	writeit(what, str)
#define	writeitvar(what, str, mywhat)

Functions
bool	isbinary (io_buf &i)
size_t	readto (io_buf &i, char *&pointer, char terminal)
size_t	bin_read (io_buf &i, char *data, size_t len, const char *read_message)
size_t	bin_write (io_buf &o, const char *data, uint32_t len)
size_t	bin_text_write (io_buf &io, char *data, size_t len, std::stringstream &msg, bool text)
size_t	bin_text_read_write (io_buf &io, char *data, size_t len, const char *read_message, bool read, std::stringstream &msg, bool text)
size_t	bin_text_write_fixed (io_buf &io, char *data, size_t len, std::stringstream &msg, bool text)
size_t	bin_text_read_write_fixed (io_buf &io, char *data, size_t len, const char *read_message, bool read, std::stringstream &msg, bool text)
size_t	bin_text_read_write_fixed_validated (io_buf &io, char *data, size_t len, const char *read_message, bool read, std::stringstream &msg, bool text)

Macro Definition Documentation

O_LARGEFILE

#define O_LARGEFILE   0

Definition at line 24 of file io_buf.h.

Referenced by io_buf::open_file(), and parse_output_preds().

writeit

#define writeit	(		what,
			str
	)

Value:

do                                                                                        \
  {                                                                                         \
    msg << str << " = " << what << " ";                                                     \
    bin_text_read_write_fixed(model_file, (char*)&what, sizeof(what), "", read, msg, text); \
  } while (0);

Definition at line 349 of file io_buf.h.

Referenced by memory_tree_ns::save_load_example(), memory_tree_ns::save_load_memory_tree(), memory_tree_ns::save_load_node(), and recall_tree_ns::save_load_tree().

writeitvar

#define writeitvar	(		what,
			str,
			mywhat
	)

Value:

auto mywhat = (what);                                                                         \
  do                                                                                            \
  {                                                                                             \
    msg << str << " = " << mywhat << " ";                                                       \
    bin_text_read_write_fixed(model_file, (char*)&mywhat, sizeof(mywhat), "", read, msg, text); \
  } while (0);

Definition at line 356 of file io_buf.h.

Referenced by memory_tree_ns::save_load_example(), memory_tree_ns::save_load_memory_tree(), memory_tree_ns::save_load_node(), and recall_tree_ns::save_load_tree().

Function Documentation

bin_read()

size_t bin_read ( io_buf &  i, char *  data, size_t  len, const char *  read_message  )

inline

Definition at line 272 of file io_buf.h.

References io_buf::bin_read_fixed(), and THROW.

Referenced by bin_text_read_write().

{
  uint32_t obj_len;
  size_t ret = i.bin_read_fixed((char*)&obj_len, sizeof(obj_len), "");
  if (obj_len > len || ret < sizeof(uint32_t))
    THROW("bad model format!");

  ret += i.bin_read_fixed(data, obj_len, read_message);

  return ret;
}

bin_text_read_write()

size_t bin_text_read_write ( io_buf &  io, char *  data, size_t  len, const char *  read_message, bool  read, std::stringstream &  msg, bool  text  )

inline

Definition at line 304 of file io_buf.h.

References bin_read(), and bin_text_write().

Referenced by save_load_header().

{
  if (read)
    return bin_read(io, data, len, read_message);
  else
    return bin_text_write(io, data, len, msg, text);
}

bin_text_read_write_fixed()

size_t bin_text_read_write_fixed ( io_buf &  io, char *  data, size_t  len, const char *  read_message, bool  read, std::stringstream &  msg, bool  text  )

inline

Definition at line 326 of file io_buf.h.

References io_buf::bin_read_fixed(), and bin_text_write_fixed().

Referenced by bin_text_read_write_fixed_validated(), SVRG::save_load(), MARGINAL::save_load(), CB_ADF::save_load(), GD::save_load(), save_load(), GD::save_load_online_state(), save_load_sampling(), save_load_svm_model(), and save_load_tree().

{
  if (read)
    return io.bin_read_fixed(data, len, read_message);
  else
    return bin_text_write_fixed(io, data, len, msg, text);
}

bin_text_read_write_fixed_validated()

size_t bin_text_read_write_fixed_validated ( io_buf &  io, char *  data, size_t  len, const char *  read_message, bool  read, std::stringstream &  msg, bool  text  )

inline

Definition at line 335 of file io_buf.h.

References bin_text_read_write_fixed(), and THROW.

Referenced by MWT::save_load(), MARGINAL::save_load(), and save_load_header().

{
  size_t nbytes = bin_text_read_write_fixed(io, data, len, read_message, read, msg, text);
  if (read && len > 0)  // only validate bytes read/write if expected length > 0
  {
    if (nbytes == 0)
    {
      THROW("Unexpected end of file encountered.");
    }
  }
  return nbytes;
}

bin_text_write()

size_t bin_text_write ( io_buf &  io, char *  data, size_t  len, std::stringstream &  msg, bool  text  )

inline

Definition at line 291 of file io_buf.h.

References bin_write(), and io_buf::bin_write_fixed().

Referenced by bin_text_read_write().

{
  if (text)
  {
    size_t temp = io.bin_write_fixed(msg.str().c_str(), msg.str().size());
    msg.str("");
    return temp;
  }
  else
    return bin_write(io, data, (uint32_t)len);
}

bin_text_write_fixed()

size_t bin_text_write_fixed ( io_buf &  io, char *  data, size_t  len, std::stringstream &  msg, bool  text  )

inline

Definition at line 313 of file io_buf.h.

References io_buf::bin_write_fixed().

Referenced by bin_text_read_write_fixed(), save_load(), GD::save_load_online_state(), GD::save_load_regressor(), save_load_regularizer(), save_load_sampling(), and GD::write_index().

{
  if (text)
  {
    size_t temp = io.bin_write_fixed(msg.str().c_str(), msg.str().size());
    msg.str("");
    return temp;
  }
  else
    return io.bin_write_fixed(data, len);
}

bin_write()

size_t bin_write ( io_buf &  o, const char *  data, uint32_t  len  )

inline

Definition at line 284 of file io_buf.h.

References io_buf::bin_write_fixed().

Referenced by bin_text_write().

{
  o.bin_write_fixed((char*)&len, sizeof(len));
  o.bin_write_fixed(data, len);
  return (len + sizeof(len));
}

isbinary()

bool isbinary

(

io_buf &

i

)

Definition at line 45 of file io_buf.cc.

References io_buf::current, v_array< T >::end(), io_buf::files, io_buf::fill(), io_buf::head, and io_buf::space.

Referenced by io_buf::bin_write_fixed(), enable_sources(), and reset_source().

{
  if (i.space.end() == i.head)
    if (i.fill(i.files[i.current]) <= 0)
      return false;

  bool ret = (*i.head == 0);
  if (ret)
    i.head++;

  return ret;
}

readto()

size_t readto	(	io_buf &	i,
		char *&	pointer,
		char	terminal
	)

Definition at line 58 of file io_buf.cc.

References v_array< T >::begin(), io_buf::current, v_array< T >::end(), v_array< T >::end_array, io_buf::files, io_buf::fill(), io_buf::head, readto(), v_array< T >::size(), and io_buf::space.

Referenced by io_buf::bin_write_fixed(), read_features(), and readto().

{
  // Return a pointer to the bytes before the terminal.  Must be less than the buffer size.
  pointer = i.head;
  while (pointer < i.space.end() && *pointer != terminal) pointer++;
  if (pointer != i.space.end())
  {
    size_t n = pointer - i.head;
    i.head = pointer + 1;
    pointer -= n;
    return n + 1;
  }
  else
  {
    if (i.space.end() == i.space.end_array)
    {
      size_t left = i.space.end() - i.head;
      memmove(i.space.begin(), i.head, left);
      i.head = i.space.begin();
      i.space.end() = i.space.begin() + left;
      pointer = i.space.end();
    }
    if (i.current < i.files.size() && i.fill(i.files[i.current]) > 0)  // more bytes are read.
      return readto(i, pointer, terminal);
    else if (++i.current < i.files.size())  // no more bytes, so go to next file.
      return readto(i, pointer, terminal);
    else  // no more bytes to read, return everything we have.
    {
      size_t n = pointer - i.head;
      i.head = pointer;
      pointer -= n;
      return n;
    }
  }
}