lokinet/llarp/bencode.hpp

#ifndef LLARP_BENCODE_HPP
#define LLARP_BENCODE_HPP
#include <llarp/buffer.h>
#include <list>
#include <string>

namespace llarp
{
  template<typename ValType>
  bool BEncode(const ValType & t, llarp_buffer_t * buff);

  template<typename ValType>
  bool BDecode(ValType & t, llarp_buffer_t * buff);

  static bool bencodeDict(llarp_buffer_t * buff)
  {
    static uint8_t c = 'd';
    return llarp_buffer_write(buff, &c, 1);
  }
  
  static bool bencodeList(llarp_buffer_t * buff)
  {
    static uint8_t c = 'l';
    return llarp_buffer_write(buff, &c, 1);
  }
  
  static bool bencodeEnd(llarp_buffer_t * buff)
  {
    static char c = 'e';
    return llarp_buffer_write(buff, &c, 1);
  }

  static bool bencodeDictKey(llarp_buffer_t * buff, const std::string & key)
  {
    std::string kstr = std::to_string(key.size()) + ":" + key;
    return llarp_buffer_write(buff, kstr.c_str(), kstr.size());
  }
  
  template<typename IntType>
  static bool bencodeDict_Int(llarp_buffer_t * buff, const std::string & key, IntType i)
  {
    std::string istr = "i" + std::to_string(i) + "e";
    return bencodeDictKey(buff, key) &&
      llarp_buffer_write(buff, istr.c_str(), istr.size());
  }

  static bool bencodeDict_Bytes(llarp_buffer_t * buff, const std::string & key, const void * data, size_t sz)
  {
    std::string sz_str = std::to_string(sz) + ":";
    return bencodeDictKey(buff, key) &&
      llarp_buffer_write(buff, sz_str.c_str(), sz_str.size()) &&
      llarp_buffer_write(buff, data, sz);
  }


  template<typename T>
  bool BEncode(const std::list<T> & l, llarp_buffer_t * buff)
  {
    if(bencodeList(buff))
    {
      for(const auto & itr : l)
        if(!BEncode(itr, buff))
          return false;
      return bencodeEnd(buff);
    }
    return false;
  }
}

#endif