jrtti is a C++ template library providing reflection capabilities
jrtti - C++ Introspection is a C++ class template library providing reflection capabilities for C++ programing language.
jrtti - C++ Introspection provides reflection abstraction for standard and custom C++ types and classes. This reflection abstraction exposes class members at run time, wich can be accessed by its string name.
It also provides a string representation of class members that can be used for object serialization and deserialization through arbitrary class reflection.
Find detailed C++ reflection library documentation at http://jseto.github.com/jrtti/doc/
You can get jrtti - C++ Introspection from GitHub at https://github.com/jseto/jrtti
jrtti - C++ Introspection uses header-only Boost C++ libraries. Download boost from http://www.boost.org/ and make sure your compiler have access to boost include directory.
jrtti - C++ Introspection test use gtest testing framework. If you plan to run the test download gtest from http://code.google.com/p/googletest/ and install it.
jrtti - C++ Introspection is a header-only library. Just make sure your compiler has access to jrtti include directory and add #include to your source code. Make sure boost header file path is available to your project.
This easy example shows the main capabilities and usage of jrtti - C++ Introspection to provide reflection capabilities to your c++ classes and members. For more detailed samples see sample.cpp and tests under the test directory.
#include <iostream>
#include <jrtti/jrtti.hpp>
// Define C++ classes for reflection
struct Position {
int x;
int y;
};
class Ball
{
public:
Ball() : m_color( "green" )
{};
// color getter
std::string getColor()
{
return m_color;
}
// position setter
void setPosition( const Position& pos ) {
m_position = pos;
}
// position getter
Position getPosition()
{
return m_position;
}
// move ball ( method call example )
void kick()
{
std::cout << "Ball kicked far away." << std::endl;
}
private:
std::string m_color;
Position m_position;
};
int main()
{
// Make Position class available to jrtti for reflection
jrtti::declare< Position >()
.property( "x", &Position::x )
.property( "y", &Position::y );
// Make Ball class available to jrtti for reflection
jrtti::declare< Ball >()
.property( "color", &Ball::getColor )
.property( "position", &Ball::setPosition, &Ball::getPosition )
.method< void >( "kick", &Ball::kick );
// Use jrtti and its reflection capabilities
Ball ball;
Position pos;
pos.x = 10; pos.y = 40;
// set the ball position using reflection
jrtti::metatype< Ball >().property( "position" ).set( &ball, pos );
//get a Metatype object from reflection database
jrtti::Metatype & mt = jrtti::metatype< Ball >();
//and working with it accessing properties as an array
std::cout << "Ball color: " << mt[ "color" ].get< std::string >( &ball ) << std::endl;
//call a reflected method
mt.call< void >( "kick", &ball );
//change the property value by full categorized name
mt.apply( &ball, "position.x", 34 );
//and get it
std::cout << mt.eval<int>( &ball, "position.x" ) << std::endl;
//get object string representation
std::cout << mt.toStr( &ball );
std::cin.ignore(1);
return 0;
}
There are VSC++ and Codegear project files under the test directory. As said above, test are coded using gtest. Install gtest in your system as well as boost libraries and add the following environment variables:
BOOST_ROOT -> points to your boost directory
GTEST_ROOT -> points to your gtest directory
Make available jrtti/include path to the compiler include path. Install gtest, and make include and library files to the compiler and linker.
You can check the wiki. If you do not find the answer, twit \@jrtti_cpp for help
jrtti - C++ Introspection is an open source reflection library. You can help to improve jrtti - C++ Introspection by forking jrtti from Github and send a pull request.
If you find a bug, check if there is a open related issue about the bug you detected, if not open a new issue in Github.
jrtti - C++ Introspection is distributed under the terms of the GNU Lesser General Public License as published by the Free Software Foundation (LGPLv3).
jrtti - C++ Introspection is distributed WITHOUT ANY WARRANTY. Use at your own risk.