void CSynchInvoker::ReleaseWaiter(const type_info& info, const string& id)
{
	Key key(id, info.name());
	CLock lock(m_synchronizer);
	assert(m_key2Waiter.end() != m_key2Waiter.find(key));
	m_key2Waiter.erase(key);
}

static string GetClassName(const type_info& info)
{
    const char* name = info.name();

    // __cxa_demangle requires an output buffer
    // allocated with malloc(). Provide it.
    size_t len = 1024;
    char *buf = (char*)malloc(len);
    assert(buf != 0);

    int status = 0;
    char *res = 0;

#ifdef HAVE_GCC_ABI_DEMANGLE
    res = abi::__cxa_demangle(name, buf, &len, &status);
#endif

    if (res && status == 0)
    {
        string ret = res;
        free(res);
        return ret;
    }
    else
    {
        if (res) free(res);
        else free(buf);
        return name;
    }
}

// Generate a cache path. This must be different for different settings in order
// to prevent cache hits on different settings.
string CacheHelper::getCacheFolder(string filename,
		const type_info& dataType) const {
	
	string dataTypeName = dataType.name();
	dataTypeName.erase(
		boost::remove_if(dataTypeName, ::isdigit), dataTypeName.end());
	
	string basePath = "cache/" + m_datasetPath +
			"/" + dataTypeName;
	
	if(dataType == typeid(DatasetManager)) {
		return basePath + "/";
	}
	
	stringstream cacheNameStream;
	cacheNameStream	<< 
		"_" << m_settings->get<string>("image.type") <<
		"_" << m_settings->get<float>("image.smoothingSigma") << 
		"_" << m_settings->get<string>("features.type") <<
		"_" << m_settings->get<vector<int> >("features.gridSpacing")[0] <<
		"_" << m_settings->get<vector<int> >("features.patchSize")[0];
		
	if(dataType == typeid(ImageFeatures)) {
		return basePath + cacheNameStream.str() + "/";
	}
	
	cacheNameStream	<<
		"_" << m_settings->get<int>("codebook.textonImages") <<
		"_" << m_settings->get<int>("codebook.codewords") <<
		"_" << m_settings->get<string>("histogram.type") <<
		"_" << m_settings->get<int>("histogram.pyramidLevels");
	
	return basePath + cacheNameStream.str() + "/";
}

void CException::x_ThrowSanityCheck(const type_info& expected_type,
                                    const char* human_name) const
{
    const type_info& actual_type = typeid(*this);
    if (actual_type != expected_type) {
        ERR_POST_X(14, Warning << "CException::Throw(): throwing object of type "
                       << actual_type.name() << " as " << expected_type.name()
                       << " [" << human_name << ']');
    }
}

void CSynchInvoker::Response(const type_info& info, const CFxEventInfo& eventInfo, void* pData)
{
	Key key(eventInfo.ID, info.name());
	CLock lock(m_synchronizer);
	auto it = m_key2Waiter.find(key);
	if (m_key2Waiter.end() != it)
	{
		IWaiter* pWaiter = it->second;
		pWaiter->VResponse(eventInfo, pData);
	}
}

const string demangle(const type_info &ti)
{
  const size_t __mangle_buff_size = 1024;
  int status;
  size_t __mangle_buff_len = __mangle_buff_size;
  char __mangle_buff[__mangle_buff_size];
  /*
  Назначение третьего (__length) и четвертого (__status) аргументов неясно: в случае очевидной ошибки нехватки памяти происходит крушение процесса (Segmentation fault или Bus error). Ситуация, при которой хотя бы один из аргументов был изменен не наблюдалась
  */
  const char *mangled_name = abi::__cxa_demangle(ti.name(), __mangle_buff, &__mangle_buff_len, &status);

  return (mangled_name ? mangled_name : "<not_demangled>");
}

string
TypeInfoHelper::getClassName( const type_info &info )
{
    static const string classPrefix( "class " );
    string name( info.name() );

    bool has_class_prefix = 0 ==
#if CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST
	name.compare( classPrefix, 0, classPrefix.length() );
#else
    name.compare( 0, classPrefix.length(), classPrefix );
#endif

    return has_class_prefix ? name.substr( classPrefix.length() ) : name;
}

/**
 * Returns a human-readable type name of a type_info object.
 *
 * @param ti A type_info object.
 * @returns The type name of the object.
 */
String Utility::GetTypeName(const type_info& ti)
{
	String klass = ti.name();

#ifdef HAVE_GCC_ABI_DEMANGLE
	int status;
	char *realname = abi::__cxa_demangle(klass.CStr(), 0, 0, &status);

	if (realname != NULL) {
		klass = String(realname);
		free(realname);
	}
#endif /* HAVE_GCC_ABI_DEMANGLE */

	return klass;
}

		std::string get_type_name(const type_info& info)
		{
			std::string type_name = info.name();

			typedef std::string::size_type size_type;

			//TODO: handle case of other than MSVC compilers
			static const std::string msvc_typeid_prefix = "class ";
			size_type pos = type_name.find(msvc_typeid_prefix);

			if (std::string::npos != pos )
			{
				size_type start_pos = pos + msvc_typeid_prefix.size();
				type_name = std::string(type_name, start_pos, type_name.size() - start_pos);
			}

			return type_name;
		}

string
ClassName( const type_info& inTypeid )
{
  string result = inTypeid.name();

#ifdef __GNUC__
  int err = 0;
  char* name = abi::__cxa_demangle( result.c_str(), 0, 0, &err );
  if( name )
  {
    result = name;
    ::free( name );
  }
#endif // __GNUC__

  // To obtain a useful representation of the class name, we need to do some
  // processing that removes white space and compiler specific additions.

  // First, remove white space between template arguments and <> brackets.
  static struct
  {
    const char* original,
              * replacement;
  } replacementTable[] =
  {
    { ", ", "," },
    { "< ", "<" },
    { " >", ">" },
    { "class ", "" },
    { "struct ", "" },
    { "enum ", "" },
  };
  size_t pos;
  for( size_t r = 0; r < sizeof( replacementTable ) / sizeof( *replacementTable ); ++r )
  {
    string original = replacementTable[r].original;
    while( string::npos != ( pos = result.find( original ) ) )
      result = result.replace( pos, original.length(), replacementTable[r].replacement );
  }
  return result;
}

  void insert(to_python_function_t f, type_info source_t, PyTypeObject const* (*to_python_target_type)())
  {
#  ifdef BOOST_PYTHON_TRACE_REGISTRY
      std::cout << "inserting to_python " << source_t << "\n";
#  endif 
      entry* slot = get(source_t);
      
      assert(slot->m_to_python == 0); // we have a problem otherwise
      if (slot->m_to_python != 0)
      {
          std::string msg = (
              std::string("to-Python converter for ")
              + source_t.name()
              + " already registered; second conversion method ignored."
          );
          
          if ( ::PyErr_Warn( NULL, const_cast<char*>(msg.c_str()) ) )
          {
              throw_error_already_set();
          }
      }
      slot->m_to_python = f;
      slot->m_to_python_target_type = to_python_target_type;
  }

void function_is_not_defined(const char* function,const char* file,unsigned int line,const type_info& type) {
  const string error = format("%s:%s:%d: Function not defined by %s",file,function,line,type.name());
  if (error_callback) {
    error_callback(error);
#ifdef _WIN32
    throw RuntimeError("error callback returned: "+error);
#endif
  } else
    throw RuntimeError(error);
}

bool type_info::operator== (const type_info &rhs) const
{
    return !before (rhs) && !rhs.before (*this);
}

NotFoundException::NotFoundException(const type_info& cppType) throw()
{
    msg = "Cannot find Type with id ";
    msg += cppType.name();
}

RET type_info::operator != (const type_info& other) const
{
    return (strcmp(name(), other.name()) != 0);
}

bool type_info::operator == (type_info const& rhs) const
{
  return this == &rhs || cpprtl::rtti::aux_::strzcmp(this->name(), rhs.name());
}

	void EventService::listen(const type_info& ti, const EventCallback& cb)
	{
		_listeners[ti.hash_code()].push_back(cb);
	}

void warn_if_not_overridden(const char* function,const char* file,unsigned int line,const type_info& type) {
  Log::cerr<<format("*** GEODE_WARNING: %s:%s:%d: Function not overridden by %s",file,function,line,type.name())<<endl;
}

int type_info::before(const type_info& other) const
{
    return (strcmp(name(), other.name()) < 0);
}

#include <elm/enum_info.h>

using namespace elm;

typedef enum {
	a,
	b,
	c
} my_enum;

namespace elm { template <> struct type_info<my_enum>: public enum_info<my_enum> { }; }

TEST_BEGIN(enum_info)

	// enumeration test
	type_info<my_enum>::iterator i = type_info<my_enum>::begin();
	CHECK(i != type_info<my_enum>::end());
	CHECK(i.name() == "a");
	CHECK(i.value() == int(a));
	i++;
	CHECK(i != type_info<my_enum>::end());
	CHECK(i.name() == "b");
	CHECK(i.value() == int(b));
	i++;
	CHECK(i != type_info<my_enum>::end());
	CHECK(i.name() == "c");
	CHECK(i.value() == int(c));
	i++;
	CHECK(i == type_info<my_enum>::end());

	// IO test