From 8f1abdd4be1d57918574170e240ddbd080c37267 Mon Sep 17 00:00:00 2001
From: Peter Conrad <conrad@quisquis.de>
Date: Sat, 2 Mar 2019 18:56:07 +0100
Subject: [PATCH] Delete unused backup(?) file

---
 include/fc/io/datastream_back.hpp | 178 ------------------------------
 1 file changed, 178 deletions(-)
 delete mode 100644 include/fc/io/datastream_back.hpp

diff --git a/include/fc/io/datastream_back.hpp b/include/fc/io/datastream_back.hpp
deleted file mode 100644
index 8c4e092..0000000
--- a/include/fc/io/datastream_back.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-#pragma once
-#include <fc/utility.hpp>
-#include <string.h>
-#include <stdint.h>
-
-namespace fc {
-
-/**
- *  The purpose of this datastream is to provide a fast, effecient, means
- *  of calculating the amount of data "about to be written" and then
- *  writing it.  This means having two modes of operation, "test run" where
- *  you call the entire pack sequence calculating the size, and then 
- *  actually packing it after doing a single allocation.
- */
-template<typename T>
-class datastream {
-   public:
-      datastream( T start, size_t s )
-      :_start(start),_pos(start),_end(start+s){};
-      
-      
-      inline void skip( size_t s ){ _pos += s; }
-      inline bool read( char* d, size_t s ) {
-        if( size_t(_end - _pos) >= (size_t)s ) {
-          memcpy( d, _pos, s );
-          _pos += s;
-          return true;
-        }
-        detail::throw_datastream_range_error( _end-start, int64_t(-((_end-_pos) - 1)))
-        return false;
-      }
-      
-      inline bool write( const char* d, size_t s ) {
-        if( _end - _pos >= (int32_t)s ) {
-          memcpy( _pos, d, s );
-          _pos += s;
-          return true;
-        }
-        detail::throw_datastream_range_error( _end-start, int64_t(-((_end-_pos) - 1)))
-        return false;
-      }
-      
-      inline bool   put(char c) { 
-        if( _pos < _end ) {
-          *_pos = c; 
-          ++_pos; 
-          return true;
-        }
-        detail::throw_datastream_range_error( _end-start, int64_t(-((_end-_pos) - 1)))
-      }
-      
-      inline bool   get( unsigned char& c ) { return get( *(char*)&c ); }
-      inline bool   get( char& c ) {
-        if( _pos < _end ) {
-          c = *_pos;
-          ++_pos; 
-          return true;
-        }
-        detail::throw_datastream_range_error( _end-start, int64_t(-((_end-_pos) - 1)))
-      }
-      
-      T               pos()const        { return _pos;                               }
-      inline bool     valid()const      { return _pos <= _end && _pos >= _start;  }
-      inline bool     seekp(size_t p) { _pos = _start + p; return _pos <= _end; }
-      inline size_t   tellp()const      { return _pos - _start;                     }
-      inline size_t   remaining()const  { return _end - _pos;                       }
-    private:
-      T _start;
-      T _pos;
-      T _end;
-};
-
-template<>
-class datastream<size_t> {
-   public:
-     datastream( size_t init_size = 0):_size(init_size){};
-     inline bool     skip( size_t s )                 { _size += s; return true;  }
-     inline bool     write( const char* d,size_t s )  { _size += s; return true;  }
-     inline bool     put(char c)                      { ++_size; return  true;    }
-     inline bool     valid()const                     { return true;              }
-     inline bool     seekp(size_t p)                  { _size = p;  return true;  }
-     inline size_t   tellp()const                     { return _size;             }
-     inline size_t   remaining()const                 { return 0;                 }
-  private:
-     size_t _size;
-};
-
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const int32_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, int32_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const uint32_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, uint32_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const int64_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, int64_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const uint64_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, uint64_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const int16_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, int16_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const uint16_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, uint16_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const int8_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, int8_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-template<typename ST>
-inline datastream<ST>& operator<<(datastream<ST>& ds, const uint8_t& d) {
-  ds.write( (const char*)&d, sizeof(d) );
-  return ds;
-}
-
-template<typename ST, typename DATA>
-inline datastream<ST>& operator>>(datastream<ST>& ds, uint8_t& d) {
-  ds.read((char*)&d, sizeof(d) );
-  return ds;
-}
-
-
-} // namespace fc
-