ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Reference

Header <alps/osiris/archivedump.h>
Header <alps/osiris/boost/array.h>
Header <alps/osiris/boost/ublas.h>
Header <alps/osiris/buffer.h>
Header <alps/osiris/comm.h>
Header <alps/osiris/dump.h>
Header <alps/osiris/dumparchive.h>
Header <alps/osiris/mpdump.h>
Header <alps/osiris/process.h>
Header <alps/osiris/std/deque.h>
Header <alps/osiris/std/impl.h>
Header <alps/osiris/std/list.h>
Header <alps/osiris/std/map.h>
Header <alps/osiris/std/pair.h>
Header <alps/osiris/std/set.h>
Header <alps/osiris/std/stack.h>
Header <alps/osiris/std/string.h>
Header <alps/osiris/std/valarray.h>
Header <alps/osiris/std/vector.h>
Header <alps/osiris/xdrcore.h>
Header <alps/osiris/xdrdump.h>
namespace alps {
  template<typename ARCHIVE> class archive_odump;
  template<typename ARCHIVE> class archive_idump;
}
namespace alps {
  template<typename T, std::size_t N> 
    alps::IDump & operator>>(alps::IDump & dump, boost::array< T, N > & x);
  template<typename T, std::size_t N> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const boost::array< T, N > & x);
}
namespace alps {
  template<typename T, typename STORAGE> 
    alps::IDump & 
    operator>>(alps::IDump & dump, 
               boost::numeric::ublas::vector< T, STORAGE > & x);

  // serialize a boost::numeric::ublas::vector container 
  template<typename T, typename STORAGE> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const boost::numeric::ublas::vector< T, STORAGE > & x);
}
namespace alps {
  ALPS_DECL void comm_init(int & argc, char **& argv, bool = false);
  ALPS_DECL void comm_exit(bool kill_slaves = false);
  ALPS_DECL bool runs_parallel();
  ALPS_DECL bool is_master();
  Process local_process();
  ProcessList all_processes();
  Process master_process();
}
namespace alps {
  class ODump;
  class IDump;
  template<typename T> ODump & operator<<(ODump & d, const T & x);
  template<typename T> 
    ODump & operator<<(ODump & d, const std::complex< T > & x);
  template<typename T> IDump & operator>>(IDump & d, T & x);
  template<typename T> IDump & operator>>(IDump & d, std::complex< T > & x);
}
namespace alps {
  class odump_archive;
  class idump_archive;
  template<typename T, typename ARCHIVE> T get(ARCHIVE & ar);
}
namespace alps {
  class OMPDump;
  class IMPDump;
}
namespace alps {
  class Process;

  typedef std::vector< Process > ProcessList;
  std::ostream & operator<<(std::ostream & out, const alps::Process & p);
}
namespace alps {

  // deserialize a std::deque container 
  template<typename T, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::deque< T, Allocator > & x);

  // serialize a std::deque container 
  template<typename T, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const std::deque< T, Allocator > & x);
}

_HAS_ARRAY(T)
namespace alps {

  // deserialize a std::list container 
  template<typename T, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::list< T, Allocator > & x);

  // serialize a std::list container 
  template<typename T, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const std::list< T, Allocator > & x);
}
namespace alps {

  // deserialize a std::map container 
  template<typename Key, typename T, typename Compare, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::map< Key, T, Compare, Allocator > & x);

  // serialize a std::map container 
  template<typename Key, typename T, typename Compare, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const std::map< Key, T, Compare, Allocator > & x);

  // deserialize a std::multimap container 
  template<typename Key, typename T, typename Compare, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, 
               std::multimap< Key, T, Compare, Allocator > & x);

  // serialize a std::multimap container 
  template<typename Key, typename T, typename Compare, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const std::multimap< Key, T, Compare, Allocator > & x);
}
namespace alps {
  template<typename T1, typename T2> 
    alps::IDump & operator>>(alps::IDump & dump, std::pair< T1, T2 > & x);
  template<typename T1, typename T2> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const std::pair< T1, T2 > & x);
}
namespace alps {

  // deserialize a std::set container 
  template<typename T, typename Compare, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::set< T, Compare, Allocator > & x);

  // serialize a std::set container 
  template<typename T, typename Compare, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const std::set< T, Compare, Allocator > & x);

  // deserialize a std::multiset container 
  template<typename T, typename Compare, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::multiset< T, Compare, Allocator > & x);

  // serialize a std::multiset container 
  template<typename T, typename Compare, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const std::multiset< T, Compare, Allocator > & x);
}
namespace alps {
  template<typename T, typename Sequence> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::stack< T, Sequence > & x);
  template<typename T, typename Sequence> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const std::stack< T, Sequence > & x);
}
namespace alps {
  template<typename charT, typename traits, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, 
               std::basic_string< charT, traits, Allocator > & s);
  alps::IDump & operator>>(alps::IDump & dump, std::string & s);
  template<typename charT, typename traits, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const std::basic_string< charT, traits, Allocator > & s);
  alps::ODump & operator<<(alps::ODump & dump, const std::string & s);
}
namespace alps {

  // deserialize a std::valarray container 
  template<typename T> 
    alps::IDump & operator>>(alps::IDump & dump, std::valarray< T > & x);

  // serialize a std::valarray container 
  template<typename T> 
    alps::ODump & operator<<(alps::ODump & dump, const std::valarray< T > & x);
}
namespace alps {
  template<typename T, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::vector< T, Allocator > & x);

  // serialize a std::vector container 
  template<typename T, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const std::vector< T, Allocator > & x);

  // serialize a std::vector<bool> from compressed form 
  template<typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, std::vector< bool, Allocator > & x);

  // serialize a std::vector<bool> in compressed form 
  template<typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, const std::vector< bool, Allocator > & x);
}

bool_t
enum_t
FALSE
TRUE
BYTES_PER_XDR_UNIT
RNDUP(x)
XDR_GETINT32(xdrs, int32p)
xdr_getint32(xdrs, int32p)
XDR_PUTINT32(xdrs, int32p)
xdr_putint32(xdrs, int32p)
XDR_GETLONG(xdrs, longp)
xdr_getlong(xdrs, longp)
XDR_PUTLONG(xdrs, longp)
xdr_putlong(xdrs, longp)
XDR_GETBYTES(xdrs, addr, len)
xdr_getbytes(xdrs, addr, len)
XDR_PUTBYTES(xdrs, addr, len)
xdr_putbytes(xdrs, addr, len)
XDR_GETPOS(xdrs)
xdr_getpos(xdrs)
XDR_SETPOS(xdrs, pos)
xdr_setpos(xdrs, pos)
XDR_INLINE(xdrs, len)
xdr_inline(xdrs, len)
XDR_DESTROY(xdrs)
xdr_destroy(xdrs)
NULL_xdrproc_t
IXDR_GET_INT32(buf)
IXDR_PUT_INT32(buf, v)
IXDR_GET_U_INT32(buf)
IXDR_PUT_U_INT32(buf, v)
IXDR_GET_LONG(buf)
IXDR_PUT_LONG(buf, v)
IXDR_GET_U_LONG(buf)
IXDR_PUT_U_LONG(buf, v)
IXDR_GET_BOOL(buf)
IXDR_GET_ENUM(buf, t)
IXDR_GET_SHORT(buf)
IXDR_GET_U_SHORT(buf)
IXDR_PUT_BOOL(buf, v)
IXDR_PUT_ENUM(buf, v)
IXDR_PUT_SHORT(buf, v)
IXDR_PUT_U_SHORT(buf, v)
MAX_NETOBJ_SZ
struct XDR;
struct xdr_discrim;
struct netobj;

typedef struct XDR XDR;
typedef bool_t(* xdrproc_t;
typedef struct netobj netobj;
bool_t xdr_void(void);
bool_t xdr_short(XDR * __xdrs, short * __sp);
bool_t xdr_u_short(XDR * __xdrs, u_short * __usp);
bool_t xdr_int(XDR * __xdrs, int * __ip);
bool_t xdr_u_int(XDR * __xdrs, u_int * __up);
bool_t xdr_long(XDR * __xdrs, long * __lp);
bool_t xdr_u_long(XDR * __xdrs, u_long * __ulp);
bool_t xdr_int8_t(XDR * __xdrs, int8_t * __ip);
bool_t xdr_uint8_t(XDR * __xdrs, uint8_t * __up);
bool_t xdr_int16_t(XDR * __xdrs, int16_t * __ip);
bool_t xdr_uint16_t(XDR * __xdrs, uint16_t * __up);
bool_t xdr_int32_t(XDR * __xdrs, int32_t * __ip);
bool_t xdr_uint32_t(XDR * __xdrs, uint32_t * __up);
bool_t xdr_int64_t(XDR * __xdrs, int64_t * __ip);
bool_t xdr_uint64_t(XDR * __xdrs, uint64_t * __up);
bool_t xdr_bool(XDR * __xdrs, bool_t * __bp);
bool_t xdr_enum(XDR * __xdrs, enum_t * __ep);
bool_t xdr_array(XDR * _xdrs, caddr_t * __addrp, u_int * __sizep, 
                 u_int __maxsize, u_int __elsize, xdrproc_t __elproc);
bool_t xdr_bytes(XDR * __xdrs, char ** __cpp, u_int * __sizep, 
                 u_int __maxsize);
bool_t xdr_opaque(XDR * __xdrs, caddr_t __cp, u_int __cnt);
bool_t xdr_string(XDR * __xdrs, char ** __cpp, u_int __maxsize);
bool_t xdr_union(XDR * __xdrs, enum_t * __dscmp, char * __unp, 
                 __const struct xdr_discrim * __choices, xdrproc_t dfault);
bool_t xdr_char(XDR * __xdrs, char * __cp);
bool_t xdr_u_char(XDR * __xdrs, u_char * __cp);
bool_t xdr_vector(XDR * __xdrs, char * __basep, u_int __nelem, 
                  u_int __elemsize, xdrproc_t __xdr_elem);
bool_t xdr_float(XDR * __xdrs, float * __fp);
bool_t xdr_double(XDR * __xdrs, double * __dp);
bool_t xdr_reference(XDR * __xdrs, caddr_t * __xpp, u_int __size, 
                     xdrproc_t __proc);
bool_t xdr_pointer(XDR * __xdrs, char ** __objpp, u_int __obj_size, 
                   xdrproc_t __xdr_obj);
bool_t xdr_wrapstring(XDR * __xdrs, char ** __cpp);
u_long xdr_sizeof(xdrproc_t, void *);
bool_t xdr_netobj(XDR * __xdrs, struct netobj * __np);
void xdrmem_create(XDR * __xdrs, __const caddr_t __addr, u_int __size, 
                   enum xdr_op __xop);
void xdrstdio_create(XDR * __xdrs, FILE * __file, enum xdr_op __xop);
void xdrrec_create(XDR * __xdrs, u_int __sendsize, u_int __recvsize, 
                   caddr_t __tcp_handle, 
                   int(*)(char *, char *, int) __readit, 
                   int(*)(char *, char *, int) __writeit);
bool_t xdrrec_endofrecord(XDR * __xdrs, bool_t __sendnow);
bool_t xdrrec_skiprecord(XDR * __xdrs);
bool_t xdrrec_eof(XDR * __xdrs);
void xdr_free(xdrproc_t __proc, char * __objp);
namespace alps {
  class OXDRDump;
  class IXDRDump;
  class OXDRFileDump;
  class IXDRFileDump;
}
Copyright 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext