src/glove/devices/DeviceManager.hpp

/*************************************************************************************
 * Copyright (c) 2009-2010, Christian Wressnegger
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * The names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *************************************************************************************/

#ifndef __GLOVE_DEVICES_DEVICEMANAGER_H_
#define __GLOVE_DEVICES_DEVICEMANAGER_H_

#include "../config.hpp"

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <stdexcept>

#include <boost/cast.hpp>
#include <boost/exception.hpp>
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/io.hpp>

#include "Device.hpp"

BOOST_FUSION_ADAPT_STRUCT(
    glove::devices::device_info,
    (int, id)
    (std::string, name)
    (std::string, type)
    (std::string, description)
)

namespace glove {
namespace devices {

template<typename DeviceType>
class API DeviceManager {
protected:
  std::map<std::string, DeviceType*> devices;

public:
  DeviceManager() {
  }

  virtual ~DeviceManager() {
    typename std::map<std::string, DeviceType*>::iterator itr;
    for (itr = devices.begin(); itr != devices.end(); ++itr) {
      delete itr->second;
    }
  }

  DeviceType& getDevice(const std::string& key) {
    typename std::map<std::string, DeviceType*>::iterator match = devices.find(key);
    if (match == devices.end()) {
      std::ostringstream oss;
      oss << "Illegal device id '" << key << "'";
      boost::throw_exception(std::invalid_argument(oss.str()));
    }
    return *match->second;
  }

  template<typename T>
  T& getDevice(const std::string& key) {
    return *boost::polymorphic_cast<T*>(&getDevice(key));
  }

  DeviceType& operator[](const std::string& key) {
    return getDevice(key);
  }

  DeviceType& getDevice(const int id) {
    if (id < 0 && (size_t) id >= devices.size()) {
      boost::throw_exception(std::invalid_argument("Illegal device id"));
    }
    typename std::map<std::string, DeviceType*>::iterator itr = devices.begin();
    for (int i = 0; i < id; i++, itr++)
      ;
    return *itr->second;
  }

  template<typename T>
  T& getDevice(const int id) {
    return *boost::polymorphic_cast<T*>(&getDevice(id));
  }

  template<typename T>
  T& getDevice(const int id, const std::string& type) {
    Device& d = getDevice(id);
    if (d.getTypeIdentifier() != type) {
      std::ostringstream oss;
      oss << "This is not a '" << type << "' device.";
      boost::throw_exception(std::invalid_argument(oss.str()));
    }
    return *boost::polymorphic_cast<T*>(&getDevice(id));
  }

  DeviceType& operator[](const int key) {
    return getDevice(key);
  }

  std::size_t numDevices() const {
    return devices.size();
  }

  const std::vector<std::string> getDeviceList() {
    std::vector<std::string> v;

    int i = 0;
    typename std::map<std::string, DeviceType*>::iterator itr;
    for (itr = devices.begin(); itr != devices.end(); ++itr, i++) {
      std::ostringstream oss;
      oss << "[" << i << "] " << itr->first << " (" << itr->second->getTypeIdentifier() << "): "
          << itr->second->toString();
      v.push_back(oss.str());
    }
    return v;
  }

  virtual std::string toString() {
    std::ostringstream oss;

    size_t i = 0;
    const std::vector<std::string> v = getDeviceList();
    std::vector<std::string>::const_iterator itr;
    for (itr = v.begin(); itr != v.end(); ++itr, i++) {
      oss << *itr;

      // TODO: skip the last endl instead of adding endl every but the last time.
      if (i < devices.size() - 1) {
        oss << std::endl;
      }
    }
    return oss.str();
  }

  template<typename Iterator>
  struct DeviceGrammar: boost::spirit::qi::grammar<Iterator, device_info()> {
    boost::spirit::qi::rule<Iterator, device_info()> start;
    boost::spirit::qi::rule<Iterator, std::string()> string_;
    boost::spirit::qi::rule<Iterator, std::string()> string_wo_space;
    boost::spirit::qi::rule<Iterator, std::string()> string_wo_rbrace;
    boost::spirit::qi::rule<Iterator, std::string()> name;
    boost::spirit::qi::rule<Iterator, std::string()> type;

    DeviceGrammar() :
      DeviceGrammar::base_type(start) {

      using boost::spirit::eps;
      using boost::spirit::lit;
      using boost::spirit::int_;
      using boost::spirit::char_;
      using boost::spirit::lexeme;
      using boost::phoenix::push_back;
      using boost::phoenix::construct;
      namespace arg = boost::spirit::arg_names;

      string_ %= lexeme[+char_];
      string_wo_space %= lexeme[+(char_ - ' ')];
      string_wo_rbrace %= lexeme[+(char_ - ')')];

      name = +(string_wo_space[arg::_val += arg::_1] >> (&lit(" (") | lit(" ")[arg::_val += " "]));
      type
          = +(string_wo_rbrace[arg::_val += arg::_1] >> (&lit("): ") | lit(")")[arg::_val += ")"]));

      start %= lit("[") >> int_ >> lit("] ") >> name >> lit(" (") >> type >> lit("): ") >> string_;
    }
  };

  static device_info parseDeviceInfo(std::string str) {
    static DeviceGrammar<std::string::const_iterator> deviceGrammar;

    device_info result;
    std::string::const_iterator begin = str.begin();
    std::string::const_iterator end = str.end();

    if (!boost::spirit::qi::parse(begin, end, deviceGrammar, result)) {
      boost::throw_exception(std::runtime_error("Illegal device info string"));
    }
    return result;
  }
};

}
}

#endif /* __GLOVE_DEVICES_DEVICEMANAGER_H_ */

---