serialization.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_DATABASE_SERIALIZATION
#define __SSRC_WSPR_DATABASE_SERIALIZATION

#include <ssrc/wispers/database/Database.h>
#include <ssrc/wisp/serialization.h>

__BEGIN_NS_SSRC_WSPR_DATABASE

using NS_SSRC_SPREAD::detail::ByteBuffer;

template<typename SerializableType, typename PackerType>
inline NS_SSRC_WSPR_DATABASE::blob_type to_blob(const SerializableType & obj,
                                               PackerType & packer,
                                               ByteBuffer & buffer)
  SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure)
{
  buffer.clear();
  return NS_SSRC_WSPR_DATABASE::blob_type(static_cast<const void *>(&buffer[0]),
                                         packer.pack(obj, buffer));
}

namespace detail {
  template<typename Packer, typename T, bool is_basic_type> struct SVBinder;

  template<typename Packer, typename T> struct SVBinder<Packer, T, true> {
    static void bind(PreparedStatement & statement,
                     const unsigned int index, const T & value,
                     Packer &, ByteBuffer &)
    {
      statement.bind(index, value);
    }
  };

  template<typename Packer, typename T> struct SVBinder<Packer, T, false> {
    static void bind(PreparedStatement & statement,
                     const unsigned int index, const T & value,
                     Packer & packer, ByteBuffer & buffer)
    {
      buffer.clear();
      statement.bind(index,
                     static_cast<const void *>(&buffer[0]),
                     packer.pack(value, buffer));
    }
  };
}

template<typename PackerType>
class SerializableValueBinder {
  typedef PackerType packer_type;

  packer_type & _packer;
  ByteBuffer & _buffer;
  PreparedStatement *_statement;

public:
  typedef SerializableValueBinder binder_type;

  SerializableValueBinder(packer_type & packer, ByteBuffer & buffer) :
    _packer(packer), _buffer(buffer), _statement(0)
  { }

  binder_type & binder(PreparedStatement & statement) {
    _statement = &statement;
    return *this;
  }

  template<typename T>
  binder_type & bind(const unsigned int index, const T & value)
    SSRC_DECL_THROW(DatabaseException)
  {
    detail::SVBinder<packer_type, T, detail::is_basic_type<T>::value>::bind(*_statement, index, value, _packer, _buffer);
    return *this;
  }

private:

  template<const unsigned int index, typename T>
  binder_type & _bindp(const T & t)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, t);
  }

  template<const unsigned int index, typename T, typename... P>
  binder_type &  _bindp(const T & t, const P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, t)._bindp<index + 1>(p...);
  }

public:

  template<typename... P>
  binder_type & bindp(const P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return _bindp<1>(p...);
  }

};

namespace detail {
  template<typename Unpacker, typename T, bool is_basic_type> struct SVLoader;

  template<typename Unpacker, typename T> struct SVLoader<Unpacker, T, true> {
    static void load(const ResultSet & result, const unsigned int index,
                     T & value, Unpacker &)
    {
      value = std::move(result.value<typename detail::ResultSetValueTraits<T, detail::is_basic_type<T>::value>::db_value_type>(index));
    }
  };

  template<typename Unpacker, typename T> struct SVLoader<Unpacker, T, false> {
    static void load(const ResultSet & result, const unsigned int index,
                     T & value, Unpacker & unpacker)
    {
      blob_type && blob = result.value<blob_type>(index);
      unpacker.unpack(value, blob.first, blob.second);
    }
  };
}

template<typename UnpackerType>
class SerializableValueLoader {
  typedef UnpackerType unpacker_type;

  unpacker_type & _unpacker;

public:

  SerializableValueLoader(unpacker_type & unpacker) :
    _unpacker(unpacker)
  { }

  template<typename T>
  SerializableValueLoader &
  load(const ResultSet & result, const unsigned int index, T & value) {
    detail::SVLoader<unpacker_type, T, detail::is_basic_type<T>::value >::load(result, index, value, _unpacker);
    return *this;
  }

private:
  template<const unsigned int index, typename T, typename... P>
  SerializableValueLoader & _loadp(const ResultSet & result,  T & value)
    SSRC_DECL_THROW(DatabaseException)
  {
    return load(result, index, value);
  }

  template<const unsigned int index, typename T, typename... P>
  SerializableValueLoader & _loadp(const ResultSet & result,  T & value, P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return load(result, index, value)._loadp<index + 1>(result, p...);
  }

public:
  template<typename... P>
  SerializableValueLoader & loadp(const ResultSet & result,  P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return _loadp<0>(result, p...);
  }

  template<const unsigned int index, typename... P>
  SerializableValueLoader & loadp(const ResultSet & result,  P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return _loadp<index>(result, p...);
  }
};

template<typename T>
inline T value(const ResultSet & result_set, const unsigned int index) {
#ifdef WSPR_DEBUG
  std::cerr << "WARNING!  POTENTIALLY INEFFICIENT BLOB DESERIALIZATION CODE PATH from ssrc/wispers/database/serialization.h.\n";
#endif
  ssrc::wisp::BinaryUnpacker unpacker;
  blob_type && blob = result_set.value<blob_type>(index);
  T value;
  unpacker.unpack(value, blob.first, blob.second);
  return value;
}

__END_NS_SSRC_WSPR_DATABASE

#endif