src/Message/Message.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

// include files
#include "Message/Message.h"
#include "Utility/Inform.h"
#include "Utility/IpplInfo.h"
#include "Profile/Profiler.h"

#ifdef IPPL_STDSTL

#include <iterator>
// Rogue Wave STL for PGI compiler doesn't have iterator_traits!!

// By now they have 2002 andreas 
#ifdef OLD_IPPL_PGI
namespace std {

template <class _Iterator>
struct iterator_traits {
  typedef typename _Iterator::iterator_category iterator_category;
  typedef typename _Iterator::value_type        value_type;
  typedef typename _Iterator::difference_type   difference_type;
  typedef typename _Iterator::pointer           pointer;
  typedef typename _Iterator::reference         reference;
};

template <class _Tp>
struct iterator_traits<_Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                         value_type;
  typedef ptrdiff_t                   difference_type;
  typedef _Tp*                        pointer;
  typedef _Tp&                        reference;
};

template <class _Tp>
struct iterator_traits<const _Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                         value_type;
  typedef ptrdiff_t                   difference_type;
  typedef const _Tp*                  pointer;
  typedef const _Tp&                  reference;
};

}
#endif // IPPL_PGI
using namespace std;

#else

#include <iterator.h>

#endif 

#ifdef IPPL_USE_STANDARD_HEADERS
#include <new>
#include <memory>
using namespace std;
#else
#include <new.h>
#include <memory.h>
#endif

#include <stdlib.h>
#include <stddef.h>

// MWERKS: moved macro definitions for MessageTypeIntrinsic to Message.h

// MWERKS: moved PutSingleItem definitions to Message.h

// definitions for non-templated static member functions of PutSingleItem
// can remain here.  JCC

// specialization to a non-built-in type, which is never assumed to be a ptr

template <class T>
Message&
PutSingleItem<T, false, false>::put(Message& msg, const T& cvalue)
{
  T& value = const_cast<T&>(cvalue);
  value.putMessage(msg);
  return msg;
}

template <class T>
Message&
PutSingleItem<T, false, false>::get(Message& msg, T& value)
{
  value.getMessage(msg);
  return msg;
}

template <class T>
Message&
PutSingleItem<T, false, false>::put(Message& m, T beg, T end)
{
  // get the value type using iterator traits
  typedef typename iterator_traits<T>::value_type T2;

  // make sure this is not empty ... if so, just create an empty item
  if (beg == end) {
    m.putmsg(0, sizeof(T2), 0);
  }
  else {
    // find the number of elements in this iterator range
    unsigned int d = 0;
    T f;
    for (f = beg; f != end; ++d, ++f);

    // if DoCopy is false, we must assume the iterators are pointers
    // to simple data types, and so we can just cast the pointer to
    // void and store it
    if (!m.willCopy()) {
#ifdef __MWERKS__
      m.putmsg((void*) (&*beg), sizeof(T2), d);
#else
  // Is this bad C++ or mwerks bug? Certain STL implems this might be wrong:
      m.putmsg((void*) (&*beg), sizeof(T2), d);
      //m.putmsg((void*) beg, sizeof(T2), d);
#endif // __MWERKS__
    }
    else {
      // make a copy ourselves
      // use malloc to get block, placement new for each element
      T2* cpydata = static_cast<T2*>( malloc(sizeof(T2) * d) );
      T2* cpy = cpydata;
      T i;
      for (i = beg; i != end; ++i, ++cpy)
        new (cpy) T2(*i);

      // put data into this message
      m.setCopy(false);
      m.setDelete(true);
      m.putmsg( (void*) cpydata, sizeof(T2), d );
    }
  }
  return m;
}

template <class T>
Message&
PutSingleItem<T, false, false>::put(Message& m,
                                    const vector<size_t>& indices, T beg)
{
  // get the value type using iterator traits
  typedef typename iterator_traits<T>::value_type T2;

  // make sure this is not empty ... if so, just create an empty item
  if (indices.begin() == indices.end()) {
    m.putmsg(0, sizeof(T2), 0);
  }
  else {
    // find the number of elements in this iterator range
    vector<size_t>::size_type d = indices.size();

    // make a copy of the data ourselves
    // use malloc to get block, placement new for each element
    T2* cpydata = static_cast<T2*>( malloc(sizeof(T2) * d) );
    T2* cpy = cpydata;
    vector<size_t>::const_iterator i, iend = indices.end();
    for (i = indices.begin(); i != iend; ++i, ++cpy)
      new (cpy) T2(beg[*i]);

    // put data into this message
    m.setCopy(false);
    m.setDelete(true);
    m.putmsg( (void*) cpydata, sizeof(T2), d );
  }
  return m;
}

template <class T>
Message&
PutSingleItem<T, false, false>::get_iter(Message& m, T o)
{
  // get the value type using iterator traits
  typedef typename iterator_traits<T>::value_type T2;

  // check to see if there is an item
  if ( m.empty() ) {
    ERRORMSG("get_iter(): no more items in Message" << endl);
  }
  else {
    // get the next MsgItem off the top of the list
    Message::MsgItem& mitem = m.item(0);

    // copy the data pointer
    T2* data = static_cast<T2*>( mitem.data() );
    int i;
    for (i = mitem.numElems(); i > 0; i--)
      *o++ = *data++;

    // delete this MsgItem
    m.get();
  }
  return m;
}


// specialization to a built-in type that is not a pointer

template <class T>
Message&
PutSingleItem<T, true, false>::put(Message& msg, const T& value)
{
  T& ncval = const_cast<T&>(value);  
  return msg.putmsg( (void*) &ncval, sizeof(T) );
}

template <class T>
Message&
PutSingleItem<T, true, false>::get(Message& msg, T& value)
{
  return msg.getmsg( (void*) &value );
}


// specialization to a pointer to a built-in type. In this class, we
// know that 'T' is a pointer type.


template <class T>
Message&
PutSingleItem<T, true, true>::put(Message& msg, T beg, T end)
{
  typedef typename iterator_traits<T>::value_type value_type;
  return msg.putmsg( (void*) beg,
                     sizeof(value_type),
                     (end - beg) );
}

template <class T>
Message&
PutSingleItem<T, true, true>::get(Message& msg, T ptr)
{
    return msg.getmsg( (void*) ptr );
}

template <class T>
Message&
PutSingleItem<T, true, true>::put(Message& m,
                                  const vector<size_t>& indices, T beg)
{
  return PutSingleItem<T, false, false>::put(m, indices, beg);
}

template <class T>
Message&
PutSingleItem<T, true, true>::get_iter(Message& m, T o)
{
  return PutSingleItem<T, false, false>::get_iter(m, o);
}


/***************************************************************************
 * $RCSfile: Message.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:28 $
 * IPPL_VERSION_ID: $Id: Message.cpp,v 1.1.1.1 2003/01/23 07:40:28 adelmann Exp $ 
 ***************************************************************************/

---