? ? ? ? ? ?

---

Package.cxx

Go to the documentation of this file.

#include "Package.h"
#include "tree_node.h"

Package::database& Package::get_database ()
{
  static database db;
  
  return (db);
}
  
Package& Package::create (const cmt_string& p, 
                          const cmt_string& v, 
                          const cmt_string& pp, 
                          const cmt_string& a)
{
  database& db = get_database ();

  bool has_wild_card = false;
  cmt_string v_prefix = v;
  cmt_regexp* v_exp = 0;
  int pos;

  if ((pos = v.find ("*")) != cmt_string::npos)
    {
      has_wild_card = true;
      v_prefix.erase (pos);

      cmt_string v_text_exp = "^";
      v_text_exp += v_prefix;

      v_exp = new cmt_regexp (v_text_exp);
    }
  
  for (int i = 0; i < db.size (); i++)
    {
      Package& entry = db[i];
      if ((entry.package == p) &&
          (entry.path == pp))
        {
          if (has_wild_card)
            {
              if (v_exp->match (entry.version))
                {
                  return (entry);
                }
            }
          else
            {
              if (entry.version == v)
                {
                  return (entry);
                }
            }
        }
    }
  
  Package& entry = db.add ();
    //entry.set (p, v_prefix, pp, a);
  entry.set (p, v, pp, a);

  return (entry);
}
  
Package::Package ()
{
  unreachable = false;
  done = false;
  node = 0;
  m_has_version_directory = true;
  m_auto_imports = true;
  m_is_public = true;
}
  
bool Package::is_unreachable () const
{
  return (unreachable);
}

void Package::set_unreachable ()
{
  unreachable = true;
}

bool Package::is_done () const
{
  return (done);
}

void Package::set_done ()
{
  done = true;
}

int Package::operator == (const Package& other) const
{
  if (package != other.package) return (0);
  if (version != other.version) return (0);
  if (path    != other.path) return (0);
  if (area    != other.area) return (0);
  return (1);
}
  
int Package::operator != (const Package& other) const
{
  const Package& me = *this;
  return (!(me == other));
}
  
const cmt_string& Package::get_name () const
{
  return (package);
}
  
const cmt_string& Package::get_version () const
{
  return (version);
}
  
const cmt_string& Package::get_path () const
{
  return (path);
}
  
const cmt_string& Package::get_dot_name () const
{
  return (dot_name);
}
  
const cmt_string& Package::get_cluster_name () const
{
  static const cmt_string top = "top";
  if (cluster_name == "") return (top);
  return (cluster_name);
}
  
const cmt_string& Package::get_dot_label () const
{
  return (dot_label);
}

cmt_string Package::to_string () const
{
  cmt_string result;
  result += package;
  result += " ";
  result += version;
  result += " ";
  result += path;
  
  return (result);
}

void Package::set_node (tree_node* n)
{
  node = n;
}

tree_node* Package::get_node () const
{
  return (node);
}

bool Package::has_version_directory () const
{
  return (m_has_version_directory);
}

bool Package::auto_imports () const
{
  return (m_auto_imports);
}

bool Package::is_public () const
{
  return (m_is_public);
}

void Package::set_has_version_directory (bool state)
{
  m_has_version_directory = state;
}



void Package::set_auto_imports (bool state)
{
  m_auto_imports = state;
}

void Package::set_is_public (bool state)
{
  m_is_public = state;
}

void Package::collect_clients (tree_node& node)
{
  const database& db = Package::get_database ();
  for (int i = 0; i < db.size (); i++)
    {
      Package& p = db[i];
      
      if (p == *this) continue;
      
      p.check_client (*this, node);
    }
}

void Package::check_client (const Package& other, tree_node& node)
{
  //if (done) return;
  //done = true;

  //cout << "Checking if " << package << " " << version << " " << path << " is client of " << other.package << endl;

  const Package& me = *this;
  
  if (me == other) return;
  
  cmt_string req;
  
  req = area;
  if (req != "") req += CmtSystem::file_separator ();
  if (path != "")
    {
      req += path;
      req += CmtSystem::file_separator ();
    }
  req += package;
  req += CmtSystem::file_separator ();
  req += version;
  req += CmtSystem::file_separator ();
  req += "cmt";
  req += CmtSystem::file_separator ();
  req += "requirements";
  
  if (!CmtSystem::test_file (req))
    {
      req = area;
      if (req != "") req += CmtSystem::file_separator ();
      if (path != "")
        {
          req += path;
          req += CmtSystem::file_separator ();
        }
      req += package;
      req += CmtSystem::file_separator ();
      req += version;
      req += CmtSystem::file_separator ();
      req += "cmt";
      req += CmtSystem::file_separator ();
      req += "requirements";
      
      if (!CmtSystem::test_file (req)) return;
    }
  
  static cmt_regexp exp ("^use ");
  
  UseScanner scanner (other, *this, node);
  
  //cout << "req = " << req << endl;
  
  scanner.run (req, exp);
  
  //done = true;
}
  
void Package::set (const cmt_string& p, 
                   const cmt_string& v, 
                   const cmt_string& pp, 
                   const cmt_string& a)
{
  package = p;
  version = v;
  path = pp;
  area = a;
  
  dot_name = "\"";
  dot_name += package;
  dot_name += "-";
  dot_name += version;

    /*
  if (path != "")
    {
      dot_name += "-";
      dot_name += path;
    }
    */

  dot_name += "\"";
  

  cluster_name = "";
  if (path != "")
    {
      cluster_name = path;
      cluster_name.replace_all ("/", "_");
      cluster_name.replace_all ("\\", "_");
    }

  
  dot_label = "";

    /*
      if (path != "")
      {
      dot_label += path;
      dot_label += "/";
      }
    */
  
  dot_label += package;
  if (version != "*")
    {
      dot_label += "\\n";
      dot_label += version;
    }
}

void Package::reduce ()
{
  if (node == 0) return;

    //node->reduce ();
}

UseScanner::UseScanner (const Package& t,
                        Package& s,
                        tree_node& node) : 
  tested (t),
  scanned (s),
  parent_node (node)
{
}

void UseScanner::begin ()
{
  done = false;
}

void UseScanner::filter (const cmt_string& line)
{
  //cout << "  filtering [" << line << "]" << endl; 
  if (done) return;

  static int level = 0;

  CmtSystem::cmt_string_vector words;
  CmtSystem::split (line, " ", words);

  cmt_string p;
  cmt_string v;
  cmt_string pp;

  if (words.size () > 1) p = words[1];
  if (words.size () > 2) v = words[2];
  if (words.size () > 3) pp = words[3];

  Package& package = Package::create (p, v, pp);
  if (package == tested)
    {
      // here "scanned" is really using tested

      for (int j = 0; j < level; j++) cout << "  ";
      //cout << "  yes " << scanned.get_name () << " uses " << tested.get_name () << endl;
      cout << "  " << scanned.get_name () << endl;

      tree_node& node = parent_node.append (scanned);

      if (scanned.is_done ()) return;
      scanned.set_done ();

      done = true;

      level++;

      scanned.collect_clients (node);

      level--;
    }
}

void UseScanner::end ()
{
}

---