Serialize.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_SERIALIZE_H_
#define SimTK_SimTKCOMMON_SERIALIZE_H_

/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2012 Stanford University and the Authors.           *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * 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 http://www.apache.org/licenses/LICENSE-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.                                             *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon/internal/common.h"
#include "SimTKcommon/internal/ExceptionMacros.h"
#include "SimTKcommon/internal/String.h"

#include <iostream>

namespace SimTK {

//------------------------------------------------------------------------------
//                           WRITE UNFORMATTED
//------------------------------------------------------------------------------
template <class T> inline void
writeUnformatted(std::ostream& o, const T& v) {
    o << String(v);
}

template <class T> inline void
writeUnformatted(std::ostream& o, const float& v)  
{   writeUnformatted<float>(o,v); }
template <class T> inline void
writeUnformatted(std::ostream& o, const double& v) 
{   writeUnformatted<double>(o,v); }
template <class T> inline void
writeUnformatted(std::ostream& o, const long double& v) 
{   writeUnformatted<long double>(o,v); }

template <class T> inline void
writeUnformatted(std::ostream& o, const negator<T>& v) 
{   writeUnformatted(o, T(v)); }

template <class T> inline void
writeUnformatted(std::ostream& o, const std::complex<T>& v) 
{   writeUnformatted(o, v.real()); o << " "; writeUnformatted(o, v.imag()); }

template <class T> inline void
writeUnformatted(std::ostream& o, const conjugate<T>& v) 
{   writeUnformatted(o, std::complex<T>(v)); }


template <int M, class E, int S> inline void
writeUnformatted(std::ostream& o, const Vec<M,E,S>& v) {
    for (int i=0; i < M; ++i) {
        if (i != 0) o << " ";
        writeUnformatted(o, v[i]);
    }
}   
template <int N, class E, int S> inline void
writeUnformatted(std::ostream& o, const Row<N,E,S>& v) 
{   writeUnformatted(o, ~v); }

template <int M, int N, class E, int CS, int RS> inline void
writeUnformatted(std::ostream& o, const Mat<M,N,E,CS,RS>& v) {
    for (int i=0; i < M; ++i) {
        if (i != 0) o << std::endl;
        writeUnformatted(o, v[i]);
    }
} 

template <int M, class E, int RS> inline void
writeUnformatted(std::ostream& o, const SymMat<M,E,RS>& v) {
    for (int i=0; i < M; ++i) {
        if (i != 0) o << std::endl;
        writeUnformatted(o, v[i]);
    }
} 
//------------------------------------------------------------------------------
//                             READ UNFORMATTED
//------------------------------------------------------------------------------
inline bool
readOneTokenUnformatted(std::istream& in, String& token) {
    // If the stream is already bad or at eof, we fail.
    if (!in.good()) {in.setstate(std::ios::failbit); return false;}
    // Skip whitespace. Failure or eof here means no token.
    std::ws(in);
    if (!in.good()) {in.setstate(std::ios::failbit); return false;}
    in >> token; if (in.fail()) return false;
    if (token.empty()) {in.setstate(std::ios_base::failbit); return false;}
    return true;
} 

template <class T> inline bool
readUnformatted(std::istream& in, T& v) {
    String token;
    if (!readOneTokenUnformatted(in, token)) return false;
    if (!token.tryConvertTo<T>(v)) 
    {   in.setstate(std::ios::failbit); return false; }
    return true;
}

template <class T> inline bool
readUnformatted(std::istream& in, float& v) 
{   return readUnformatted<float>(in,v); }
template <class T> inline bool
readUnformatted(std::istream& in, double& v) 
{   return readUnformatted<double>(in,v); }
template <class T> inline bool
readUnformatted(std::istream& in, long double& v) 
{   return readUnformatted<long double>(in,v); }

template <class T> inline bool
readUnformatted(std::istream& in, negator<T>& v) {
    T nonneg; if (!readUnformatted(in, nonneg)) return false;
    v = nonneg; // Changes representation, not value.
    return true;
}

template <class T> inline bool
readUnformatted(std::istream& in, std::complex<T>& v) {
    T real, imag;
    if (!readUnformatted(in, real)) return false;
    if (!readUnformatted(in, imag)) return false;
    v = std::complex<T>(real,imag);
    return true;
}

template <class T> inline bool
readUnformatted(std::istream& in, conjugate<T>& v) {
    std::complex<T> cmplx; if (!readUnformatted(in, cmplx)) return false;
    v = cmplx; // Changes representation, not value.
    return true;
}

template <> inline bool 
readUnformatted<String>(std::istream& in, String& v)
{   return readOneTokenUnformatted(in,v); }


template <int M, class E, int S> inline bool
readUnformatted(std::istream& in, Vec<M,E,S>& v) {
    for (int i=0; i < M; ++i)
        if (!readUnformatted(in, v[i])) return false;
    return true;
}   

template <int N, class E, int S> inline bool
readUnformatted(std::istream& in, Row<N,E,S>& v) 
{   return readUnformatted(in, ~v); }

template <int M, int N, class E, int CS, int RS> inline bool
readUnformatted(std::istream& in, Mat<M,N,E,CS,RS>& v) {
    for (int i=0; i < M; ++i)
        if (!readUnformatted(in, v[i])) return false;
    return true;
} 

template <int M, class E, int RS> inline bool
readUnformatted(std::istream& in, SymMat<M,E,RS>& v) {
    Mat<M,M,E> m; if (!readUnformatted(in, m)) return false;
    if (!m.isNumericallySymmetric()) {
        in.setstate(std::ios::failbit); 
        return false;
    }
    v.setFromSymmetric(m);
    return true;
} 
//------------------------------------------------------------------------------
//                             WRITE FORMATTED
//------------------------------------------------------------------------------
template <class T> inline void
writeFormatted(std::ostream& o, const T& v) {
    o << String(v);
}
//------------------------------------------------------------------------------
//                             READ FORMATTED
//------------------------------------------------------------------------------
template <class T> inline bool
readFormatted(std::istream& in, T& v) {
    return readUnformatted(in, v);
}

// TODO: need specializations for complex to support (real,imag) where the
// numbers can be NaN, Inf, -Inf.
} // namespace SimTK
#endif // SimTK_SimTKCOMMON_SERIALIZE_H_