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:
    explicit 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, parser::options) 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::ostream & data) const override {
      data << (val.*ptr ? "true" : "false");
    }
    
  private:
    bool T::*ptr;
  };
  
  template <typename T, typename N>
  class direct_binder<T, N, typename std::enable_if<std::is_integral<N>::value>::type> : public binder_impl<T> {
  public:
    explicit direct_binder(N T::*p) : ptr(p) {}
    virtual binder_impl<T>* clone() const override { return new direct_binder(*this); }
    
    virtual void parse(T& val, char const*& data, parser::options) const override {
      json::helper::parse_numeric(val.*ptr, data);
    }
    
    virtual void write(T const& val, std::ostream & data) const override {
      data << val.*ptr;
    }
  private:
    N T::*ptr;
  };
  
  template <typename T, typename N>
  class direct_binder<T, N, typename std::enable_if<std::is_floating_point<N>::value>::type> : public binder_impl<T> {
  public:
    explicit direct_binder(N T::*p) : ptr(p) {}
    virtual binder_impl<T>* clone() const override { return new direct_binder(*this); }
    
    virtual void parse(T& val, char const*& data, parser::options) const override {
      json::helper::parse_double(val.*ptr, data);
    }
    
    virtual void write(T const& val, std::ostream & data) const override {
      data << val.*ptr;
    }
  private:
    N T::*ptr;
  };
  
  template <typename T>
  class direct_binder<T, std::string> : public binder_impl<T> {
  public:
    explicit 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, parser::options) const override {
      json::helper::parse_string(val.*ptr, data);
    }
    
    virtual void write(T const& val, std::ostream & data) const override {
      data << "\"" << val.*ptr << "\"";
    }
  private:
    std::string T::*ptr;
  };
} }