cpp-json/json/json_direct_scalar_binder.hpp

//
//  json_direct_scalar_binder.hpp
//  json
//
//  Created by Sam Jaffe on 4/23/16.
//

#pragma once

namespace json { namespace binder {
  template <typename T>
  class direct_binder<T, bool> : public binder_impl<T> {
  public:
    direct_binder(bool T::*p) : ptr(p) {}
    virtual binder_impl<T>* clone() const override { return new direct_binder(*this); }
    
    virtual void parse(T& val, char const*& data) const override {
      if (!strncmp(data, "true", 4)) {
        val.*ptr = true;
      } else if (!strncmp(data, "false", 5)) {
        val.*ptr = false;
      } else {
        throw json::malformed_json_exception("Expected a boolean type here");
      }
    }
    
    virtual void write(T const& val, std::string & data) const override {
      data += (val.*ptr ? "true" : "false");
    }
    
  private:
    bool T::*ptr;
  };
  
  template <typename T>
  class direct_binder<T, int> : public binder_impl<T> {
  public:
    direct_binder(int T::*p) : ptr(p) {}
    virtual binder_impl<T>* clone() const override { return new direct_binder(*this); }
    
    virtual void parse(T& val, char const*& data) const override {
      json::helper::parse_integer(val.*ptr, data);
    }
    
    virtual void write(T const& val, std::string & data) const override {
      char buffer[16] = { '\0' };
      snprintf(buffer, sizeof(buffer), "%d", val.*ptr);
      data += buffer;
    }
  private:
    int T::*ptr;
  };
  
  template <typename T>
  class direct_binder<T, double> : public binder_impl<T> {
  public:
    direct_binder(double T::*p) : ptr(p) {}
    virtual binder_impl<T>* clone() const override { return new direct_binder(*this); }
    
    virtual void parse(T& val, char const*& data) const override {
      json::helper::parse_double(val.*ptr, data);
    }
    
    virtual void write(T const& val, std::string & data) const override {
      char buffer[32] = { '\0' };
      snprintf(buffer, sizeof(buffer), "%lf", val.*ptr);
      data += buffer;
    }
  private:
    double T::*ptr;
  };
  
  template <typename T>
  class direct_binder<T, std::string> : public binder_impl<T> {
  public:
    direct_binder(std::string T::*p) : ptr(p) {}
    virtual binder_impl<T>* clone() const override { return new direct_binder(*this); }
    
    virtual void parse(T& val, char const*& data) const override {
      json::helper::parse_string(val.*ptr, data);
    }
    
    virtual void write(T const& val, std::string & data) const override {
      data += "\"" + val.*ptr + "\"";
    }
  private:
    std::string T::*ptr;
  };
} }