? ? ? ? ? ?

---

cmtshowclients.cxx

Go to the documentation of this file.

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

class FileScanner
{
public:
  class actor
  {
public:
    virtual ~actor ()
        {
        }

    virtual void run (const cmt_string& /*package*/,
                      const cmt_string& /*version*/,
                      const cmt_string& /*path*/)
        {
        }
  };

  FileScanner ();
  bool scan_path (const cmt_string& path, actor& a);

private:
  void scan_path (const cmt_string& path, int level, actor& a);

  bool _running;
  int _level;
};


//----------------------------------------------------------
FileScanner::FileScanner ()
//----------------------------------------------------------
{
  _running = false;
  _level = 0;
}

//----------------------------------------------------------
bool FileScanner::scan_path (const cmt_string& path, actor& a)
//----------------------------------------------------------
{
  if (_running) return (false);

  _level = 0;
  _running = true;
  scan_path (path, 0, a);
  _running = false;
  _level = 0;

  return (true);
}

//----------------------------------------------------------
void FileScanner::scan_path (const cmt_string& path, int level, actor& a)
//----------------------------------------------------------
{
    //
    // Only do something if it is a directory.
    //

  if (!CmtSystem::test_directory (path)) return;

  CmtSystem::cmt_string_vector list;

  CmtSystem::scan_dir (path, list);

  if (list.size () == 0) return;

  _level++;

    // Will be set if at least one directory is a version directory
  bool has_package = false;

  cmt_string pack;
  CmtSystem::basename (path, pack);

  int i;
  for (i = 0; i < list.size (); i++)
    {
      const cmt_string& name = list[i];

        //cout << "scan> level=" << level << " name=" << name;

      cmt_string version;
      CmtSystem::basename (name, version);

        //
        //  All entries at this level may be "legal" version directories.
        //
        //  So we go down but no more then one level deep.
        //  The next level we request that the entry is a version
        //  and that there is a mgr/requirements file below.
        //

      if (level == 0)
        {
            //cout << " -> down" << endl;
          scan_path (name, level + 1, a);
        }
      else if (CmtSystem::is_version_directory (version))
        {
          cmt_string req;

          req = name;
          req += CmtSystem::file_separator ();
          req += "cmt";
          req += CmtSystem::file_separator ();
          req += "requirements";

          if (CmtSystem::test_file (req))
            {
                //cout << " -> cmt" << endl;

              a.run (pack, version, path);

              has_package = true;
            }
          else
            {
                //cout << " -> no cmt" << endl;
              req = name;
              req += CmtSystem::file_separator ();
              req += "mgr";
              req += CmtSystem::file_separator ();
              req += "requirements";

              if (CmtSystem::test_file (req))
                {
                    //cout << " -> cmt" << endl;

                  a.run (pack, version, path);

                  has_package = true;
                }
              else
                {
                    //cout << " -> no mgr" << endl;
                }
            }
        }
      else
        {
            //cout << " -> stop" << endl;
        }
    }

  if (has_package)
    {
        //
        // At least one version was found here.
        //
      scan_path (path, 0, a);
    }

  _level--;
}


class PackageViewer : public FileScanner::actor
{
public:
  void run (const cmt_string& package,
            const cmt_string& version,
            const cmt_string& path)
      {
        cmt_string null;
        cmt_string offset = path;

        offset.replace (path_prefix, null);
        offset.replace (CmtSystem::file_separator (), null);
        offset.replace (package, null);
        
        if (CmtSystem::file_separator () == '\\')
          {
            offset.replace_all (CmtSystem::file_separator (), '/');
          }
        
        int pos = offset.find_last_of ('/');
        if (pos == (offset.size () - 1)) offset.erase (pos);
        
          //cout << package << " " << version << " " << offset << " " << path_prefix << endl;
        Package::create (package, version, offset, path_prefix);
      }
  
  void set_path (const cmt_string& path)
      {
        path_prefix = path;
      }
  
private:
  cmt_string path_prefix;
};

int main (int argc, char* argv[])
{
  if (argc < 3) return (1);

  cmt_string p;
  p = argv[1];
  cmt_string v;
  v = argv[2];
  cmt_string pp;
  if (argc >= 3) pp = argv[3];

  Package& top_package = Package::create (p, v, pp);
  tree_node top_node (0, &top_package);

  cmt_string cmt_version;
  CmtSystem::get_cmt_version (cmt_version);
  Package::create ("CMT", cmt_version, "");

  FileScanner scanner;
  PackageViewer viewer;

  CmtSystem::cmt_string_vector paths;
  CmtSystem::cmt_string_vector path_pwds;
  CmtSystem::cmt_string_vector path_sources;

  CmtSystem::get_cmt_paths (paths, path_pwds, path_sources);

  for (int path_index = 0; path_index < paths.size (); path_index++)
    {
      const cmt_string& path = paths[path_index];
      viewer.set_path (path);
      scanner.scan_path (path, viewer);
    }

  top_package.collect_clients (top_node);

  DotGenerator generator;

  generator.run (top_node, "back");

  return (0);
}

---