Formatting.Helpers.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.  
* 
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law 
* and international copyright treaties. 
* 
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting 
* a non-assignable, non-transferable and non-exclusive license to use the software 
* for it's own data processing purposes under the terms defined in the Agreement.
* 
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part 
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited. 
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with 
* the terms of the Agreement is a violation of copyright law. 
*/

// Formatting helpers
#pragma once

#include <stdexcept>
#include <util/TextBuilder.h>

#include "BookImpl.h"
#include "NamespaceHelper.h"

namespace OnixS { 
namespace Util {

// std::pair formatting
template<typename TFirst, typename TSecond>
inline TextBuilder & operator<<(TextBuilder & tb, const std::pair<TFirst, TSecond> & obj) {
  return tb << obj.first << ':' << obj.second;
}

// Wrapper for join collection items using delimiter during formatting
template<class Container> 
struct JoinWrapper /*: public boost::noncopyable*/
{
  const Container & container;
  const char * const delimiter;

  explicit
  JoinWrapper(const Container & ctnr, const char * delim = "\n") 
    : container(ctnr)
    , delimiter(delim) 
  {
    if(delimiter == nullptr)
      throw std::invalid_argument("JoinWrapper::ctor, delimiter can not be NULL");
  }
  JoinWrapper(const JoinWrapper& other)
    : container(other.container), delimiter(other.delimiter){}

private:
    JoinWrapper& operator=(const JoinWrapper&);
};

// creates JoinWrapper
template<class Container> 
inline 
JoinWrapper<Container> join(const Container & container, const char * delimiter) 
{
  return JoinWrapper<Container>(container, delimiter);
}

// Joins members of wrapped container using delimiters
template<class Container> 
inline
TextBuilder & operator<<(TextBuilder & tb, const JoinWrapper<Container> & wrapper) 
{
  const char * const delimiter = wrapper.delimiter;
  typename Container::const_iterator it = wrapper.container.begin(), e = wrapper.container.end();
  
  if(it != e) {
    tb << *it;
    ++it;
    for(; it != e; ++it) 
      tb << delimiter << *it ;
  }  
  return tb;
}

inline
TextBuilder & operator<<(TextBuilder & tb, const HANDLER_NAMESPACE::OrderBookInternal& book)
{
    tb << book.toFormattedString();
    return tb;
}

}} // ::OnixS::Util

ONIXS_HANDLER_NAMESPACE_BEGIN

using Util::TextBuilder;

// Effective formatting output to std::ostream using TextBuilder
template<typename TObj>
std::ostream & TextBuilderToStdStream(std::ostream & stream, const TObj & obj);

// Effective formatting output to std::ostream using TextBuilder
template<typename TObj>
std::ostream & TextBuilderToStdStream(std::ostream & stream, const TObj * obj);

/////////////////////////////////////////////////////////////////////////////////////////
// Inline implementation

template<typename TObj>
inline
std::ostream & TextBuilderToStdStream(std::ostream & stream, const TObj & obj) {
  TextBuilder tb; 
  return stream << (tb << obj).toString();
}

template<typename TObj>
inline
std::ostream & TextBuilderToStdStream(std::ostream & stream, const TObj * obj) {
  TextBuilder tb; 
  return stream << (tb << obj).toString();
}

ONIXS_HANDLER_NAMESPACE_END