PropertiesToString.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * 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
 *
 *     https://www.savarese.com/software/ApacheLicense-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.
 */

#ifndef __SSRC_WSPR_UTILITY_PROPERTIES_TO_STRING_H
#define __SSRC_WSPR_UTILITY_PROPERTIES_TO_STRING_H

#include <iosfwd>

#include <ssrc/wispers/utility/Properties.h>
#include <ssrc/wispers/utility/ToString.h>

__BEGIN_NS_SSRC_WSPR_UTILITY

void escape_lua(string & result,
                const char *text, const unsigned int text_size);

inline void escape_lua(string & result, const string & text) {
  escape_lua(result, text.c_str(), text.size());
}

inline string escape_lua(const string & text) {
  string result;
  escape_lua(result, text);
  return result;
}

// Converts Properties to a string representation that can be read by a
// Lua interpreter.  Probably should be moved to the lua package because
// we could also have JSON and other string representations.
class PropertiesToString : public boost::static_visitor<void> {
public:
  enum ToFormat { ToDefault = 0, ToLua = 0, ToJSON = 1 };

private:
  const char * const * const _token;
  std::ostream & _out;

public:

  explicit PropertiesToString(std::ostream & out,
                              const ToFormat to_format = ToDefault);

  void operator()(const primitive_property_vector & v) const;
  void operator()(const property_vector & v) const;

  void operator()(const bool v) const {
    _out << (v ? "true" : "false");
  }

  // Convert 64-bit integers to string representation because Lua/JavaScript
  // usually support only 32-bit integers.
  void operator()(const std::int64_t v) const {
    _out << "\"" << v << "\"";
  }

  void operator()(const std::uint64_t v) const {
    _out << "\"" << v << "\"";
  }

  // Convert 32-bit unsigned integers to equivalent 2's complement
  // signed integer, allowing the original value to be recovered via
  // a cast when read back.
  void operator()(const std::uint32_t v) const {
    _out << static_cast<std::int32_t>(v);
  }

  void operator()(const string & s) const {
    _out << "\"" << escape_lua(s) << "\"";
  }

  void operator()(const Properties & properties) const {
    if(properties.is_leaf()) {
      const property_type *v = properties.value();
      if(v != 0) {
        boost::apply_visitor(*this, *v);
      }
    } else {
      _out << "{";
      properties.visit(*this);
      _out << "}";
    }
  }

  template<typename T>
  void operator()(const T & v) const {
    _out << v;
  }

  void enter(const std::string & key, const Properties *props,
             const bool is_last_child) const;

  void leave(const std::string & key, const Properties *props,
             const bool is_last_child) const
  {
    if(props->is_leaf()) {
      if(!is_last_child) {
        _out << ",";
      }
    } else {
      if(is_last_child) {
        _out << "}";
      } else {
        _out << "},";
      }
    }
  }
};

inline
std::ostream & operator<<(std::ostream & out, const Properties & properties) {
  PropertiesToString tostring(out);
  tostring(properties);
  return out;
}

__END_NS_SSRC_WSPR_UTILITY

#endif