JSON.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_JSON_H_
#define _MIRA_JSON_H_

#include <iostream>

#ifndef Q_MOC_RUN
#include <json_spirit_value.h>
#endif

#include <error/Exceptions.h>

#include <serialization/IsAtomicSerializable.h>

#include <utils/Singleton.h>

#include <stream/BinaryStream.h>

#ifndef MIRA_WINDOWS
// export the json templates to avoid recurring instantiations and therefore reduce compile time
extern template class json_spirit::Config_map<std::string>;
extern template class json_spirit::Value_impl<json_spirit::Config_map<std::string>>;
#endif

namespace mira {


namespace json {



template <typename T>
struct IsBaseType :
    boost::mpl::bool_<boost::is_same<T, std::string>::value || boost::is_arithmetic<T>::value>
{};

template <typename T>
struct TypeTrait
{
    typedef T type;
};

#define MIRA_JSON_TRAIT(B,T)  \
template <>                   \
struct TypeTrait<T>           \
{                             \
    typedef B type;           \
};

MIRA_JSON_TRAIT(int, char)
MIRA_JSON_TRAIT(int, uint8)
MIRA_JSON_TRAIT(int, uint16)
MIRA_JSON_TRAIT(int64, uint32)
MIRA_JSON_TRAIT(int, int8)
MIRA_JSON_TRAIT(int, int16)
MIRA_JSON_TRAIT(int, int32)
MIRA_JSON_TRAIT(double, float)
MIRA_JSON_TRAIT(double, long double)



template <typename T>
typename TypeTrait<T>::type cast(const T& value)
{
    return static_cast<typename TypeTrait<T>::type>(value);
}

template <typename T>
T reverse_cast(const typename TypeTrait<T>::type& value)
{
    return static_cast<T>(value);
}



class JSONDefaultPrecision : public Singleton<JSONDefaultPrecision>
{
    friend class singleton::CreateUsingNew<JSONDefaultPrecision>;

protected:
    JSONDefaultPrecision() : mPrecision(MIRA_JSON_DEFAULT_PRECISION) {}

    static const unsigned int MIRA_JSON_DEFAULT_PRECISION = 3;

public:
    static void set(unsigned int precision) { instance().mPrecision = precision; }

    static void reset() { instance().mPrecision = MIRA_JSON_DEFAULT_PRECISION; }

    static unsigned int get() { return instance().mPrecision; }

private:
    unsigned int mPrecision;
};


typedef json_spirit::mValue  Value;

typedef json_spirit::mObject Object;

typedef json_spirit::mArray  Array;


MIRA_BASE_EXPORT void write(const Value& value, std::ostream& ioStream,
                            bool formatted=false, int precision = -1);

MIRA_BASE_EXPORT std::string write(const Value& value, bool formatted=false,
                                   int precision = -1);

MIRA_BASE_EXPORT void read(const std::string& s, Value& oValue);

MIRA_BASE_EXPORT void read(std::istream& ioStream, Value& oValue);

MIRA_BASE_EXPORT inline void read(std::string::const_iterator& begin,
                                  std::string::const_iterator& end,
                                  Value& oValue);

MIRA_BASE_EXPORT Value getElement(const Value& iValue,
                                  const std::string& elementName);

MIRA_BASE_EXPORT bool hasElement(const Value& iValue, const std::string& element);

struct QueryValueResult {
    bool exists;
    Value value;          
    std::string error;    
};

MIRA_BASE_EXPORT QueryValueResult getElementIfExists(const Value& iValue,
                                                     const std::string& elementName);

MIRA_BASE_EXPORT double getNumberElement(const Value& iValue,
                                         const std::string& elementName);

MIRA_BASE_EXPORT bool hasNumberElement(const Value& iValue, const std::string& element);

struct QueryNumberResult {
    bool exists;
    double number;          
    std::string error;      
};

MIRA_BASE_EXPORT QueryNumberResult getNumberElementIfExists(const Value& iValue,
                                                            const std::string& elementName);


} // json


typedef json::Value  JSONValue;
typedef json::Object JSONObject;
typedef json::Array  JSONArray;

template <>
class IsAtomicSerializable<JSONValue> : public std::true_type {};


} // namespace mira

namespace json_spirit {


template <typename OStream>
inline OStream& operator<<(OStream& os, const mira::JSONValue& value)
{
    os << mira::json::write(value, false);
    return os;
}

inline mira::BinaryStlOstream& operator<<(mira::BinaryStlOstream& os, const mira::JSONValue& value)
{
    os << mira::json::write(value, false, 0);
    return os;
}

inline mira::BinaryBufferOstream& operator<<(mira::BinaryBufferOstream& os, const mira::JSONValue& value)
{
    os << mira::json::write(value, false, 0);
    return os;
}

template <typename IStream>
inline IStream& operator>>(IStream& is, mira::JSONValue& value)
{
    std::string tmp;
    is >> tmp;
    mira::json::read(tmp, value);
    return is;
}

template <typename CharT>
inline std::basic_stringstream<CharT>& operator>>(std::basic_stringstream<CharT>& is, mira::JSONValue& value)
{
    mira::json::read(is, value);
    is.seekg(-1, std::ios_base::cur);
    return is;
}


} // namespace json_spirit


#endif