class_alloc_filter.h

Go to the documentation of this file.

// $Header$
//
// Copyright (C) 2002 - 2004, by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.
//
 
#ifndef LIBCWD_CLASS_ALLOC_FILTER_H
#define LIBCWD_CLASS_ALLOC_FILTER_H
 
#ifndef LIBCWD_LIBRARIES_DEBUG_H
#error "Don't include <libcwd/class_alloc_filter.h> directly, include the appropriate \"debug.h\" instead."
#endif
 
#include "config.h"
 
#if CWDEBUG_LOCATION
#include "class_location.h"
#endif
 
#if CWDEBUG_ALLOC
 
#if CWDEBUG_LOCATION
#include "private_allocator.h"
#endif
#ifndef LIBCW_VECTOR
#define LIBCW_VECTOR
#include <vector>
#endif
#include <sys/time.h>
 
#endif // CWDEBUG_ALLOC
 
namespace libcwd {
 
typedef unsigned short int alloc_format_t;
 
#if CWDEBUG_LOCATION
alloc_format_t const show_path = 1;                     
alloc_format_t const show_objectfile = 2;               
alloc_format_t const show_function = 4;                 
#endif
#if CWDEBUG_ALLOC
alloc_format_t const show_time = 8;                     
alloc_format_t const show_allthreads = 16;              
#if CWDEBUG_LOCATION
alloc_format_t const format_mask = (show_time|show_path|show_objectfile|show_function|show_allthreads);
#else
alloc_format_t const format_mask = (show_time|show_allthreads);
#endif
#endif // CWDEBUG_ALLOC
 
#if CWDEBUG_ALLOC
 
unsigned int const hide_untagged = 32;                  // Call hide_untagged_allocations() to set this flag.
unsigned int const hide_unknown_loc = 64;               // Call hide_unknown_locations() to set this flag.
 
class dm_alloc_base_ct;
class dm_alloc_copy_ct;
#if CWDEBUG_MARKER
class marker_ct;
#endif
 
class alloc_filter_ct {
private:
#if CWDEBUG_LOCATION            // No synchronization needed when not defined.
  static int S_next_id;         // MT: protected by list_allocations_instance
  static int S_id;              // MT: protected by list_allocations_instance
  int M_id;
#endif
  friend class ::libcwd::dm_alloc_base_ct;
  friend class ::libcwd::dm_alloc_copy_ct;
  alloc_format_t M_flags;
  struct timeval M_start;
  struct timeval M_end;
#if CWDEBUG_LOCATION
  typedef std::basic_string<char, std::char_traits<char>, _private_::auto_internal_allocator> string_type;
  typedef std::vector<string_type, _private_::auto_internal_allocator::rebind<string_type>::other> vector_type;
  vector_type M_objectfile_masks;
  vector_type M_sourcefile_masks;
  typedef std::vector<std::pair<string_type, string_type>,
      _private_::auto_internal_allocator::rebind<std::pair<string_type, string_type> >::other> vector_pair_type;
  vector_pair_type M_function_masks;
#endif
public:
  static struct timeval const no_time_limit;
  alloc_filter_ct(alloc_format_t flags = 0);
  void set_flags(alloc_format_t flags);
  alloc_format_t get_flags() const;
  struct timeval get_time_start() const;
  struct timeval get_time_end() const;
#if CWDEBUG_LOCATION
  std::vector<std::string> get_objectfile_list() const;
 
  std::vector<std::string> get_sourcefile_list() const;
 
  std::vector<std::pair<std::string, std::string> > get_function_list() const;
#endif
 
  void set_time_interval(struct timeval const& start, struct timeval const& end);
 
#if CWDEBUG_LOCATION
  void hide_objectfiles_matching(std::vector<std::string> const& masks);
 
  void hide_sourcefiles_matching(std::vector<std::string> const& masks);
 
  void hide_functions_matching(std::vector<std::pair<std::string, std::string> > const& masks);
#endif
 
  void hide_untagged_allocations(bool hide = true) { if (hide) M_flags |= hide_untagged; else M_flags &= ~hide_untagged; }
 
  void hide_unknown_locations(bool hide = true) { if (hide) M_flags |= hide_unknown_loc; else M_flags &= ~hide_unknown_loc; }
 
#if CWDEBUG_LOCATION
  // Return true if filepath matches one of the masks in M_source_masks.
  _private_::hidden_st check_hide(char const* filepath) const;
 
  // Return true if object_file/mangled_function_name matches one of the mask pairs in M_function_masks.
  _private_::hidden_st check_hide(object_file_ct const* object_file, char const* mangled_function_name) const;
#endif
 
private:
  friend unsigned long list_allocations_on(debug_ct&, alloc_filter_ct const&);
#if CWDEBUG_MARKER
  friend class marker_ct;
#endif
#if CWDEBUG_LOCATION
  void M_check_synchronization() const { if (M_id != S_id) M_synchronize(); }
  void M_synchronize() const;
  void M_synchronize_locations() const;
#endif
};
 
#endif // CWDEBUG_ALLOC
 
} // namespace libcwd
 
#endif // LIBCWD_CLASS_ALLOC_FILTER_H