#include <cstdint>
#include <type_traits>
//-------------------------------------------------------------------------
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_fundamental.hpp>
//-------------------------------------------------------------------------
template <typename T, typename Predicate = void> struct BoostTest;
template <typename T> struct BoostTest <T, typename boost::enable_if<boost::is_integral<T>>::type> { };
//-------------------------------------------------------------------------
template <typename T, typename Predicate = void> struct StdTest;
template <typename T> struct StdTest <T, typename std::enable_if<std::is_integral<T>::value_type>::type> { };
//-------------------------------------------------------------------------
int main(int argc, char** argv)
{
  StdTest<int> stdOk;       // Err???
  StdTest<float> stdErr;    // Err
  BoostTest<int> boostOk;   // Ok
  BoostTest<float> boostErr;// Err
  return 0;
}

typename std::enable_if<std::is_integral<T>::value,bool>::type

typename std::enable_if<std::is_integral<T>::value>::type>

#include <tuple>
#include <vector>
#include <string>
#include <iostream>
//--------------------------------------------------------------------------
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
//--------------------------------------------------------------------------
/*
  g++ -Wall -std=gnu++0x -o ./main ./main.cpp
*/
//--------------------------------------------------------------------------
namespace qi = boost::spirit::qi;
namespace ph = boost::phoenix;
//--------------------------------------------------------------------------
typedef std::tuple<int,int,float> TpPointsTuple;
typedef std::vector<TpPointsTuple> TpPointsTempStorage;
//--------------------------------------------------------------------------
struct phoenix_get_impl
{
  template <std::size_t I,typename... Args>
  struct result
  {
    typedef typename std::tuple_element<I,std::tuple<Args...>>::type type;
  };
  template <std::size_t I,typename... Args>
  typename result<I,Args...>::type& operator () (std::tuple<Args...>& t)
  {
    return std::get<I> (t);
  }
};
ph::function<phoenix_get_impl> const phoenix_get = phoenix_get_impl();
//--------------------------------------------------------------------------
struct phoenix_make_tuple_impl
{
  template <typename... Args>
  struct result
  {
    typedef std::tuple<Args...> type;
  };
  template <typename... Args>
  typename result<Args...>::type operator () (Args... args) const
  {
    return std::make_tuple(args...);
  }
};
ph::function<phoenix_make_tuple_impl> const phoenix_make_tuple = phoenix_make_tuple_impl();
//--------------------------------------------------------------------------
template <typename Iterator>                    \
struct TpPointsParser : qi::grammar             \
<Iterator,TpPointsTempStorage(),qi::space_type> \
{
  TpPointsParser(void) : TpPointsParser::base_type(start)
  {
    int_strong %= qi::int_ >> !(qi::punct >> *qi::digit);
    sectionName = qi::alpha >> *qi::alnum >> qi::lit('=');
    requiredData = (int_strong >> int_strong >> -qi::float_)  \
      [phoenix_make_tuple(qi::_1,qi::_2,qi::_3)];
    start = sectionName >> requiredData         \
      //[ph::push_back(qi::_val,qi::_1)];
      [std::cerr << phoenix_get.operator () <0> (qi::_1)];
    return;
  }
  qi::rule<Iterator,int()> int_strong;
  qi::rule<Iterator,void(),qi::space_type> sectionName;
  qi::rule<Iterator,TpPointsTuple(),qi::space_type> requiredData;
  qi::rule<Iterator,TpPointsTempStorage(),qi::space_type> start;
};

//--------------------------------------------------------------------------
int main(int argc,char** argv)
{
//#define USE_IT
#ifdef USE_IT
  std::tuple<int,int> t(100500,9000);
  phoenix_get_impl pgi;
  std::cerr << pgi.operator () <0> (t) << std::endl;
#else
  std::string data("point0 = 9000 100500\n");
  std::string::const_iterator walker = data.begin();
  std::string::const_iterator end = data.end();
  bool result = true;
  TpPointsTempStorage tpPointsTempStorage;
  TpPointsParser<std::string::const_iterator> tpPointsParser;
  while((walker != end) && (result == true))
  {
    result = qi::phrase_parse(walker,end,tpPointsParser,qi::space,tpPointsTempStorage);
    std::cerr << std::endl;
  }
  std::cerr << "tpPointsTempStorage.size() = " \
            << tpPointsTempStorage.size()      \
            << std::endl;
#endif//USE_IT
  return 0;
}

QString AnalogClockPlugin::includeFile() const
{
 return "analogclock.h";
}

QString AnalogClockPlugin::includeFile() const
{
 return "<../examples/designer/customwidgetplugin/analogclock.h>";
}

QString value = ... ;// Строка, которую надо разобрать
std::string::const_iterator walker = value.toStdString().begin();// Итератор_1
std::string::const_iterator end = value.toStdString().end();// Итератор_2
parse_data(walker,end,...);// Функция разбора строки

#include <iostream>
//-------------------------------------------------------------------------
struct Base
{
};
//-------------------------------------------------------------------------
struct Derived : protected Base
{
 operator Base* ()
 { return static_cast<Base*>(this); }
 Derived* operator & ()
 { return this; }
};
//-------------------------------------------------------------------------
int main(int argc,char** argv)
{
 Derived derived;
 Base* pbase = static_cast<Base*>(&derived);
 return 0;
}

struct Derived : protected Base
{
 Derived& operator & ()
 { return *this; }
};