libpp/name_storage.h

/**
 * @file name_storage.h
 * Type-safe unique storage of global names (filenames and symbols)
 *
 * @remark Copyright 2002 OProfile authors
 * @remark Read the file COPYING
 *
 * @author Philippe Elie
 * @author John Levon
 */

#ifndef NAME_STORAGE_H
#define NAME_STORAGE_H

#include <string>

#include "unique_storage.h"

class extra_images;

/// store original name and processed name
struct stored_name {
	stored_name(std::string const & n = std::string())
		: name(n) {}

	bool operator<(stored_name const & rhs) const {
		return name < rhs.name;
	}

	std::string name;
	mutable std::string name_processed;
};


/// partial specialization for unique storage of names
template <typename I> struct name_storage : unique_storage<I, stored_name> {

	typedef typename unique_storage<I, stored_name>::id_value id_value;

	std::string const & name(id_value const & id) const {
		return unique_storage<I, stored_name>::get(id).name;
	}
};


class debug_name_tag;
/// a debug filename
typedef name_storage<debug_name_tag>::id_value debug_name_id;

/// class storing a set of shared debug name (source filename)
struct debug_name_storage : name_storage<debug_name_tag> {
	/// return the basename for the given ID
	std::string const & basename(debug_name_id id) const;
};

/// store original name and processed name
struct stored_filename {
	stored_filename(std::string const & n = std::string())
		: filename(n), extra_images_uid(0) {}

	bool operator<(stored_filename const & rhs) const {
		return filename < rhs.filename;
	}

	std::string filename;
	mutable std::string base_filename;
	mutable std::string real_filename;
	mutable std::string real_base_filename;
	mutable int extra_images_uid;
};

/// partial specialization for unique storage of filenames
template <typename I> 
struct filename_storage : unique_storage<I, stored_filename> {

	typedef typename unique_storage<I, stored_filename>::id_value id_value;

	std::string const & name(id_value const & id) const {
		return unique_storage<I, stored_filename>::get(id).filename;
	}
};

class image_name_tag;
/// an image name
typedef filename_storage<image_name_tag>::id_value image_name_id;

/// class storing a set of shared image name
struct image_name_storage : filename_storage<image_name_tag> {
	enum image_name_type {
		/// image name based on the sample filename w/o path
		int_basename,
		/// image name based on the sample filename
		int_filename,
		/// real image name, can be different for module.
		int_real_basename,
		/// same as int_real_basename + the complete path, including an
		/// optionnal archive_path passed trough profile_spec
		int_real_filename,
	};

	/**
	 * @param id  the image name id
	 * @param type  the image name type
	 * @param extra  extra locations where the image can be found
	 *
	 * If type == int_real_name (resp. int_real_filename) and the image
	 * can't be located the return value is the same as if get_name()
	 * was called with int_name (resp. int_filename).
	 *
	 * multiple call with the image_name_id and different extra parameter
	 * will throw a runtime error, multiple extra_images are possible
	 * with differential profile but the name. FIXME
	 */
	std::string const & get_name(image_name_id id,
				     image_name_type type,
				     extra_images const & extra) const;

	/// return the basename name for the given ID
	std::string const & basename(image_name_id) const;
};


class symbol_name_tag;
/// a (demangled) symbol
typedef name_storage<symbol_name_tag>::id_value symbol_name_id;

/// class storing a set of shared symbol name
struct symbol_name_storage : name_storage<symbol_name_tag> {
	/// return the demangled name for the given ID
	std::string const & demangle(symbol_name_id id) const;
};


/// for images
extern image_name_storage image_names;

/// for debug filenames i.e. source filename
extern debug_name_storage debug_names;

/// for symbols
extern symbol_name_storage symbol_names;


/**
 * debug name specialisation for comparison.
 *
 * We compare by name rather by id since what user will see are
 * filename and when the criteria "samples count" give identical
 * result it's better to obtain result sorted by the user visible
 * property filename rather than by an obscure, invisible from user
 * point of view, file identifier property
 */
template<> inline bool
debug_name_id::operator<(debug_name_id const & rhs) const
{
	return debug_names.name(*this) < debug_names.name(rhs);
}

#endif /* !NAME_STORAGE_H */