---

io_tools.h

Go to the documentation of this file.

#ifndef __IO_TOOLS__
#define __IO_TOOLS__


#include <iostream>

#include "msg_stream.h"


namespace IO_tools{

  template<typename T> inline void write_4_bytes(const T& v,
                                                 std::ostream& out);

  template<typename T> inline void write_2_bytes(const T& v,
                                                 std::ostream& out);

  template<typename T> inline void read_4_bytes(T* result,
                                                std::istream& in);

  template<typename T> inline void read_2_bytes(T* result,
                                                std::istream& in);

  template<typename T>
  inline void convert_bit_order(const T& var,
                                T* result);

  inline void go_to_next(const char c,
                         std::istream& in);

  inline void go_to_next_token(const std::string token,
                               std::istream& in);

  inline char go_to_next_of_list(const std::string token_list,
                                 std::istream& in);
 


/*
  ###########################################################
  ###########################################################
  ###########################################################
  ##############                               ##############
  ##############  I M P L E M E N T A T I O N  ##############
  ##############                               ##############
  ###########################################################
  ###########################################################
  ###########################################################
*/



  template<typename T>
  inline void convert_bit_order(const T& var,
                                T* result){
    
#ifdef REVERSE_BIT_ORDER
    int i;
    char* in  = reinterpret_cast<char*>(&const_cast<T&>(var));
    char* out = reinterpret_cast<char*>(result);
#endif

    int size = sizeof(T);
    switch (size){
    case 1:
      *result = var;
      return;
    case 2:
    case 4:
    
#ifdef REVERSE_BIT_ORDER
      for(i=0;i<size;i++){
        out[i] = in[size-1-i];
      }
#else
      *result = var;
#endif
    
      return;
      
    default:
      Message::error<<"convert_bit_order: variable size("
                    <<size<<") not handled"<<Message::done;
      break;
    }
  }

  template<typename T> inline void write_4_bytes(const T& v,
                                                 std::ostream& out){
#ifdef DEBUG
    if (sizeof(T)!=4) {
      Message::error<<"write_4_bytes: the variable is not coded with 4 bytes"
                    <<Message::done;
    }
#endif

    T buf;
    convert_bit_order(v,&buf);
    char* byte = (char*)(&buf);
    for(int i=0;i<4;i++){
      out.put(byte[i]);
    }
  }


  template<typename T> inline void write_2_bytes(const T& v,
                                                 std::ostream& out){
#ifdef DEBUG
    if (sizeof(T)!=2) {
      Message::error<<"write_2_bytes: the variable is not coded with 2 bytes"
                    <<Message::done;
    }
#endif

    T buf;
    convert_bit_order(v,&buf);
    char* byte = (char*)(&buf);
    for(int i=0;i<2;i++){
      out.put(byte[i]);
    }
  }

  template<typename T> inline void read_4_bytes(T* result,
                                                std::istream& in){
#ifdef DEBUG
    if (sizeof(T)!=4) {
      Message::error<<"read_4_bytes: the variable is not coded with 4 bytes"
                    <<Message::done;
    }
#endif

    T buf;
    char* byte = (char*)(&buf);

    for(int i=0;i<4;i++){
      in.get(byte[i]);
    }

    convert_bit_order(buf,result);
  }



  
  template<typename T> inline void read_2_bytes(T* result,
                                                std::istream& in){
#ifdef DEBUG
    if (sizeof(T)!=2) {
      Message::error<<"read_2_bytes: the variable is not coded with 2 bytes"
                    <<Message::done;
    }
#endif

    T buf;
    char* byte = (char*)(&buf);

    for(int i=0;i<2;i++){
      in.get(byte[i]);
    }

    convert_bit_order(buf,result);
  }



  
  void go_to_next(const char c,
                  std::istream& in){
    char ch;
    
    do{ 
      in.get(ch);
      if (!in.good()) {
        Message::error<<"go_to_next: error in input stream\nwas looking for '"
                      <<c<<"'"
                      <<Message::done;
      }
    }
    while (ch!=c);
  }

  void go_to_next_token(const std::string token,
                        std::istream& in){

    const unsigned int token_size = token.size();
    
    if (token_size<1) {
      Message::error<<"go_to_next_token: token size too small ("
                    <<token_size<<")"<<Message::done;
    }

    char ch;
    unsigned int size_found = 0;
    
    while (size_found<token_size) {   
      in.get(ch);
    
      if (!in.good()) {
        Message::error<<"go_to_next_token: error in input stream"
                      <<Message::done;
      }
    
      if (ch==token[size_found]) {
        size_found++;
      }
      else {
        size_found=0;
      }
    }
  }

  
  char go_to_next_of_list(const std::string token_list,
                          std::istream& in){
    char ch;
    bool found;

    const unsigned int list_size = token_list.size();
    
    do{ 
      in.get(ch);
      if (!in.good()) {
        Message::error<<"go_to_next: error in input stream"
                      <<Message::done;
      }

      found = false;
      for(unsigned int i=0;i<list_size;i++){
        found = found||(ch==token_list[i]);
      }
    }
    while (!found);
     
    return ch;
  }



}

#endif

---