Subversion Repositories scarts

// Copyright (C) 2005 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
 
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
 
#include <typeinfo>
#include <stdexcept>
#include <sstream>
#include <fstream>
#include <cxxabi.h>
#include <testsuite_performance.h>
 
// Ah, we wish it wasn't so...
bool first_container = false;
extern const char* filename;
 
typedef std::string::size_type (*callback_type) (std::string&);
 
template<typename Container, int Iter, bool Thread>
  void
  write_viz_container(callback_type find_container, const char* filename)
  {
    typedef std::string string;
 
    // Create title.
    {
      const char ws(' ');
      std::ostringstream title;
 
      std::string titlename(filename);
      std::string::size_type n = titlename.find('.');
      if (n != string::npos)
	titlename = std::string(titlename.begin(), titlename.begin() + n);
 
      title << titlename;
      title << ws;
      title << Iter;
      title << ws;
#if 0
      title << "thread<";
      std::boolalpha(title);
      title << Thread;
      title << '>';
#endif
 
      titlename += ".title";
      std::ofstream titlefile(titlename.c_str());
      if (!titlefile.good())
	throw std::runtime_error("write_viz_data cannot open titlename");
      titlefile << title.str() << std::endl;
    }
 
    // Create compressed type name.
    Container obj;
    int status;
    std::string type(abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status));
 
    // Extract fully-qualified typename.
    // Assumes "set" or "map" are uniquely determinate.
    string::iterator beg = type.begin();
    string::iterator end;
    string::size_type n = (*find_container)(type);
 
    // Find start of fully-qualified name.
    // Assume map, find end.
    string::size_type nend = type.find('<', n);
    if (nend != string::npos)
      end = type.begin() + nend;
 
    string compressed_type;
    compressed_type += '"';
    compressed_type += string(beg, end);
    compressed_type += '<';
#if 0
    typename Container::key_type v;
    compressed_type += typeid(v).name();
#else
    compressed_type += "int";
#endif
    compressed_type += ", A>";
 
    // XXX
    if (Thread == true)
      compressed_type += " thread";
    compressed_type += '"';
 
    std::ofstream file(filename, std::ios_base::app);
    if (!file.good())
      throw std::runtime_error("write_viz_data cannot open filename");
 
    file << compressed_type;
    first_container = false;
  }
 
 
void
write_viz_data(__gnu_test::time_counter& time, const char* filename)
{
  std::ofstream file(filename, std::ios_base::app);  
  if (!file.good())
    throw std::runtime_error("write_viz_data cannot open filename");
 
  // Print out score in appropriate column.
  const char tab('\t');
  int score = time.real_time();
  file << tab << score;
}
 
void
write_viz_endl(const char* filename)
{
  std::ofstream file(filename, std::ios_base::app);
  if (!file.good())
    throw std::runtime_error("write_viz_endl cannot open filename");
  file << std::endl;
}
 
 
#if 0
// cons
write_viz_container<container_type, Iter, Thread>(&sequence_find_container, 
						  filename);
#endif
 
#if 0
// dtor
write_viz_endl(filename)
#endif