[Compbench-devel] CompBenchmarks++/libcompbenchmarks/UI UI-Console.cpp, NONE, 1.1 UI-Console.h, NON

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/compbench/CompBenchmarks++/libcompbenchmarks/UI
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv8901

Added Files:
	UI-Console.cpp UI-Console.h UI-Msg.cpp UI-Msg.h 
Log Message:
First import.

--- NEW FILE: UI-Console.h ---
/* ----------------------------------------------------------------------------
   $Id: UI-Console.h,v 1.1 2007/06/06 15:54:38 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */

#ifndef H_CBMUI_CONSOLE
#define H_CBMUI_CONSOLE

#include <UI/UI.h>

namespace CBM {
  /** \brief Basic API for user interface.
   *
   *  This class defines few methods to interact with compbenchmarks-config, or
   *  with the console.
   */
  class UIConsole : public UI
  {
  private:
    std::string curmsg;
    int         lastisLF;

    virtual void LF(void);
  protected:
    virtual int depth(UIMsg *_msg);

    virtual UIMsg::Flags flags(UIMsg *_msg);
    virtual float progress(UIMsg *_msg);
    virtual UIMsg::ActionType action(UIMsg *_msg);
    virtual std::string objectField(UIMsg *_msg,
				    std::string _field);
    virtual int childNumber(UIMsg *_msg);
  public:
    UIConsole();

    virtual void Display(UIMsg *_msg);
    virtual void DisplayProgressUpdate(UIMsg *_msg);
    virtual void DisplayDone(UIMsg *_msg);

    virtual ~UIConsole();
  };
}

#endif

--- NEW FILE: UI-Console.cpp ---
/* ----------------------------------------------------------------------------
   $Id: UI-Console.cpp,v 1.1 2007/06/06 15:54:38 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */
#include <UI/UI-Console.h>
#include <iostream>
#include <stdlib.h>

using namespace CBM;

int uiconsole_verbose_shell = 0;

UIConsole::UIConsole()
  : UI()
{
  lastisLF=0;
}

void UIConsole::LF(void)
{
  if (!lastisLF) {
    std::cout << std::endl;
    lastisLF=1;
  }
}

int UIConsole::depth(UIMsg *_msg)
{
  int d = 0;

  while ((_msg) && (_msg->getParent())) {
    _msg=(UIMsg*)_msg->getParent()->getParent();
    if ((uiconsole_verbose_shell) ||
	(action(_msg)!=UIMsg::ShellCommand))
      d++;
  }

  return(d);
}

UIMsg::Flags UIConsole::flags(UIMsg *_msg)
{
  XMLAttribute *A = _msg->getAttribute("flags");

  if (A->Value()=="Progress")
    return(UIMsg::Progress);
  else
    return(UIMsg::NoProgress);
}

float UIConsole::progress(UIMsg *_msg)
{
  XMLNode      *N = _msg->getNode("progress");
  XMLAttribute *A;

  if (!N)
    return(0.0f);

  A=N->getAttribute("value");

  if (!A)
    return(0.0f);

  return((float)atof(A->Value().c_str()));
}

UIMsg::ActionType UIConsole::action(UIMsg *_msg)
{
  XMLNode           *N = _msg->getNode("action");
  XMLAttribute      *A;
  UIMsg::ActionType r;

  if (!N)
    return(UIMsg::UndefAction);


  A=N->getAttribute("type");
  if (!A)
    return(UIMsg::UndefAction);

  r=(UIMsg::ActionType)atoi(A->Value().c_str());

  return(r);
}

std::string UIConsole::objectField(UIMsg *_msg,
				   std::string _field)
{
  XMLNode           *N = _msg->getNode("object");
  XMLAttribute      *A;

  if (!N)
    return("");


  A=N->getAttribute(_field);
  if (!A)
    return("");

  return(A->Value());
}

int UIConsole::childNumber(UIMsg *_msg)
{
  XMLNode           *R   = _msg->getNode("childs");
  int               i, n = R->nodeNumber();
  int               r    = 0;
  XMLNode           *N;

  for(i=0;i<n;i++) {
    N=R->getNode(i);
    if ((uiconsole_verbose_shell) ||
	(action((UIMsg*)N)!=UIMsg::ShellCommand))
      r++;
  }

  return(r);
}

void UIConsole::Display(UIMsg *_msg)
{
  int d = depth(_msg);


  if ((!uiconsole_verbose_shell) &&
      (action(_msg)==UIMsg::ShellCommand))
    return;

  if ((_msg->getParent()) &&
      (_msg->getParent()->getParent())) {
    LF();
  }

  curmsg="";

  while (d--)
    curmsg+=" ";

  switch(action(_msg)) {
  case UIMsg::ShellCommand:
    curmsg+="Executing : '";
    curmsg+=objectField(_msg, "name");
    curmsg+="'";
    break;
  case UIMsg::BenchmarkBench:
    curmsg+="Benchmarking ";
    break;
  case UIMsg::PackageUninstall:
    curmsg+="Uninstalling ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackageInstall:
    curmsg+="Installing ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackageDownload:
    curmsg+="Downloading ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackageExtract:
    curmsg+="Extracting ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackagePreconfigure:
    curmsg+="Pre-configure ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackageFetch:
    curmsg+="Fetching ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackageTest:
    curmsg+="Testing ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::PackagePatch:
    curmsg+="Patching ";
    curmsg+=objectField(_msg, "name");
    break;
  case UIMsg::Checksum:
    curmsg+="Checksuming ";
    curmsg+=objectField(_msg, "name");
    break;
  default:
    curmsg+="Display::DEFAULT/";
    curmsg+=_msg->str();
    curmsg+="\n";
    break;
  }

  curmsg+=" : ";
  std::cout << curmsg;

  lastisLF=0;
  fflush(stdout);
}

void UIConsole::DisplayProgressUpdate(UIMsg *_msg)
{
  if ((!uiconsole_verbose_shell) &&
      (action(_msg)==UIMsg::ShellCommand))
    return;
  
  printf("\r%s%0.2f%%", curmsg.c_str(), progress(_msg));
  fflush(stdout);
}

void UIConsole::DisplayDone(UIMsg *_msg)
{
  XMLNode       *R = _msg->getNode("output");
  XMLNode       *N;
  XMLAttribute  *A;
  UIMsg::Status status;

  int       i, n = R->nodeNumber();
  int       d = depth(_msg);
  int       s;

  //  std::cout << _msg->str() << std::endl;

  if ((!uiconsole_verbose_shell) &&
      (action(_msg)==UIMsg::ShellCommand))
    return;

  for(i=0;i<n;i++) {
    N=R->getNode(i);
    if (N->Name()!="text")
      continue;

    A=N->getAttribute("status");
    if (!A)
      continue;

    status=(UIMsg::Status)atoi(A->Value().c_str());

    if (childNumber(_msg)) {
      s=d+1;
      while (s--)
	std::cout << " ";
    }

    if (flags(_msg)==UIMsg::Progress) {
      if ((status==UIMsg::OK) && (progress(_msg)!=100.0)) {
	_msg->setProgress(100.0);
      }
	
      std::cout << " - ";
    }

    switch(status) {
    case UIMsg::OK:
      std::cout << "OK";
      lastisLF=0;
      break;
    case UIMsg::KO:
      std::cout << "Failed.";
      lastisLF=0;
      break;
    case UIMsg::Info:
      std::cout << N->Value();
      lastisLF=0;
      break;
    }
    LF();
  }
  // lastisLF=0;
}

UIConsole::~UIConsole()
{
}

--- NEW FILE: UI-Msg.h ---
/* ----------------------------------------------------------------------------
   $Id: UI-Msg.h,v 1.1 2007/06/06 15:54:38 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */

#ifndef H_CBMUIMSG
#define H_CBMUIMSG

#include <Base/XML.h>

/*
  <msg timestamp="..." flags="[No]Progress>
   <object type="4" name="file.tar.gz"/>
   <action type="4"/>
   <output>
     <text status="info">Blah</text>
     <text status="ok"/>
   </output>
   <progress [value="4"]>
   <childs/>
  </msg>
 */
namespace CBM {
  class UIMsg : public XMLNode {
  public:

    typedef enum Flags {
      NoProgress,
      Progress
    };

    typedef enum Status {
      KO, OK, Info
    };

    typedef enum ObjectType {
      UndefObject,
      FatalError,
      Shell, File, Directory, Package, Benchmark, Compiler
    };

    typedef enum ActionType {
      UndefAction,
      ShellCommand,
      Create, Read, Write, Remove, Checksum,
      PackageInstall, PackageUninstall,
      PackageFetch,
      PackageDownload, PackageExtract, PackagePatch, PackagePreconfigure,
      PackageConfigure,
      PackageMake, PackageTest, PackageClean,
      BenchmarkBench, BenchmarkResult,
      CompilerAutodetect
    };
  private:
    XMLNode *outputNode;
    XMLNode *progressNode;
    XMLNode *childsNode;

    virtual std::string toString(int _i);
    virtual std::string toString(float _f);

  protected:
    virtual void addObject(ObjectType  _type,
			   std::string _name);
    virtual void addAction(ActionType  _type,
			   std::string _action = "");
    virtual void addOutput(Status      _status,
			   std::string _text = "");
			   

  public:
    UIMsg(Flags _flags = NoProgress);

    virtual void addChild(UIMsg *_child);

    virtual void outputOK(std::string _text = "");
    virtual void outputKO(std::string _text = "");
    virtual void outputInfo(std::string _text);
    virtual void setProgress(float _pc);
    
    virtual ~UIMsg();
  };

  class UIMsgFatal : public UIMsg {
  public:
    UIMsgFatal(std::string _text);
    virtual ~UIMsgFatal();
  };

  class UIMsgShell : public UIMsg {
  public:
    UIMsgShell(std::string _shellCommand);
    virtual ~UIMsgShell();
  };

  class UIMsgCreate : public UIMsg {
  private:
  protected:
  public:
    UIMsgCreate(ObjectType  _type,
		std::string _name);

    virtual ~UIMsgCreate();
  };

  class UIMsgDownload : public UIMsg {
  public:
    UIMsgDownload(std::string _url);

    virtual ~UIMsgDownload();
  };

  class UIMsgChecksum : public UIMsg {
  public:
    UIMsgChecksum(std::string _file);

    virtual ~UIMsgChecksum();
  };

  class UIMsgExtract : public UIMsg {
  public:
    UIMsgExtract(std::string _name);

    virtual ~UIMsgExtract();
  };

  class UIMsgPatch : public UIMsg {
  public:
    UIMsgPatch(std::string _name);

    virtual ~UIMsgPatch();
  };

  class UIMsgPreconfigure : public UIMsg {
  public:
    UIMsgPreconfigure(std::string _name);

    virtual ~UIMsgPreconfigure();
  };

  class UIMsgConfigure : public UIMsg {
  public:
    UIMsgConfigure(std::string _info);

    virtual ~UIMsgConfigure();
  };

  class UIMsgMake : public UIMsg {
  public:
    UIMsgMake(std::string _name);

    virtual ~UIMsgMake();
  };

  class UIMsgTest : public UIMsg {
  public:
    UIMsgTest(std::string _name);

    virtual ~UIMsgTest();
  };

  class UIMsgRelease : public UIMsg {
  public:
    UIMsgRelease(std::string _name);

    virtual ~UIMsgRelease();
  };

  class UIMsgInstall : public UIMsg {
  public:
    UIMsgInstall(std::string _name);

    virtual ~UIMsgInstall();
  };

  class UIMsgFetch : public UIMsg {
  public:
    UIMsgFetch(std::string _name);

    virtual ~UIMsgFetch();
  };

  class UIMsgUninstall : public UIMsg {
  public:
    UIMsgUninstall(std::string _name);

    virtual ~UIMsgUninstall();
  };

  class UIMsgBench : public UIMsg {
  public:
    UIMsgBench(std::string _name);

    virtual ~UIMsgBench();
  };
}

#endif

--- NEW FILE: UI-Msg.cpp ---
/* ----------------------------------------------------------------------------
   $Id: UI-Msg.cpp,v 1.1 2007/06/06 15:54:38 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */

#include <UI/UI-Msg.h>
#include <stdio.h>

using namespace CBM;

UIMsg::UIMsg(Flags _flags)
  : XMLNode("msg")
{
  if (_flags == NoProgress)
    addAttribute("flags", "NoProgress");
  if (_flags == Progress)
    addAttribute("flags", "Progress");

  outputNode=addNode("output");
  progressNode=addNode("progress");
  childsNode=addNode("childs");
}

std::string UIMsg::toString(int _i)
{
  char tmp[16] = { 0 };
  sprintf(tmp, "%d", _i);

  return(tmp);
}

std::string UIMsg::toString(float _f)
{
  char tmp[32] = { 0 };
  sprintf(tmp, "%f", _f);

  return(tmp);
}

void UIMsg::addObject(ObjectType  _type,
		      std::string _name)
{
  XMLNode *O = new XMLNode("object");
  
  O->addAttribute("type", toString((int) _type));

  O->addAttribute("name", _name);

  add(O);
}

void UIMsg::addAction(ActionType  _type,
		      std::string _action)
{
  XMLNode *O = new XMLNode("action");
  
  O->addAttribute("type", toString((int) _type));

  if (_action!="") {
    O->addAttribute("name", _action);
  }

  add(O);
}

void UIMsg::addOutput(Status      _status,
		      std::string _text)
{
  XMLNode *O = new XMLNode("text");
  
  O->addAttribute("status", toString((int) _status));
  if (_text!="")
    O->setValue(_text);

  outputNode->add(O);
}

void UIMsg::addChild(UIMsg *_child)
{
  childsNode->add(_child);
}

void UIMsg::outputOK(std::string _text)
{
  addOutput(OK, _text);
}

void UIMsg::outputKO(std::string _text)
{
  addOutput(KO, _text);
}

void UIMsg::outputInfo(std::string _text)
{
  addOutput(Info, _text);
}

void UIMsg::setProgress(float _pc)
{
  XMLAttribute *A = progressNode->getAttribute("value");

  if (!A)
    A=progressNode->addAttribute("value", "0");

  A->setValue(toString(_pc));
}
    
UIMsg::~UIMsg()
{
}

UIMsgFatal::UIMsgFatal(std::string _text)
  : UIMsg()
{
  addObject(FatalError, _text);
}

UIMsgFatal::~UIMsgFatal()
{
}

UIMsgShell::UIMsgShell(std::string _shellCommand)
  : UIMsg()
{
  addObject(Shell, _shellCommand);
  addAction(ShellCommand);
}

UIMsgShell::~UIMsgShell()
{
}

UIMsgCreate::UIMsgCreate(ObjectType  _type,
			 std::string _name)
  : UIMsg()
{
  addObject(_type, _name);
  addAction(Create);
}

UIMsgCreate::~UIMsgCreate()
{
}

UIMsgDownload::UIMsgDownload(std::string _url)
  : UIMsg(Progress)
{
  addObject(File, _url);
  addAction(PackageDownload);
}

UIMsgDownload::~UIMsgDownload()
{
}

UIMsgChecksum::UIMsgChecksum(std::string _file)
  : UIMsg()
{
  addObject(File, _file);
  addAction(Checksum);
}

UIMsgChecksum::~UIMsgChecksum()
{
}


UIMsgExtract::UIMsgExtract(std::string _name)
  : UIMsg()
{
  addObject(Package, _name);
  addAction(PackageExtract);
}

UIMsgExtract::~UIMsgExtract()
{
}


UIMsgPatch::UIMsgPatch(std::string _name)
  : UIMsg()
{
  addObject(Package, _name);
  addAction(PackagePatch);
}

UIMsgPatch::~UIMsgPatch()
{
}

UIMsgPreconfigure::UIMsgPreconfigure(std::string _name)
  : UIMsg(Progress)
{
  addObject(Package, _name);
  addAction(PackagePreconfigure);
}

UIMsgPreconfigure::~UIMsgPreconfigure()
{
}

UIMsgConfigure::UIMsgConfigure(std::string _info)
  : UIMsg()
{
  addObject(Package, _info);
  addAction(PackageConfigure);
}

UIMsgConfigure::~UIMsgConfigure()
{
}

UIMsgMake::UIMsgMake(std::string _info)
  : UIMsg()
{
  addObject(Package, _info);
  addAction(PackageMake);
}

UIMsgMake::~UIMsgMake()
{
}

UIMsgTest::UIMsgTest(std::string _info)
  : UIMsg()
{
  addObject(Package, _info);
  addAction(PackageTest);
}

UIMsgTest::~UIMsgTest()
{
}

UIMsgRelease::UIMsgRelease(std::string _info)
  : UIMsg()
{
  addObject(Package, _info);
  addAction(PackageClean);
}

UIMsgRelease::~UIMsgRelease()
{
}

UIMsgInstall::UIMsgInstall(std::string _info)
  : UIMsg()
{
  addObject(Package, _info);
  addAction(PackageInstall);
}

UIMsgInstall::~UIMsgInstall()
{
}

UIMsgFetch::UIMsgFetch(std::string _name)
  : UIMsg()
{
  addObject(Package, _name);
  addAction(PackageFetch);
}

UIMsgFetch::~UIMsgFetch()
{
}

UIMsgUninstall::UIMsgUninstall(std::string _name)
  : UIMsg()
{
  addObject(Package, _name);
  addAction(PackageUninstall);
}

UIMsgUninstall::~UIMsgUninstall()
{
}

UIMsgBench::UIMsgBench(std::string _name)
  : UIMsg()
{
  addObject(Benchmark, _name);
  addAction(BenchmarkBench);
}

UIMsgBench::~UIMsgBench()
{
}

[Compbench-devel] CompBenchmarks++/libcompbenchmarks/UI UI-Console.cpp, NONE, 1.1 UI-Console.h, NON

[Compbench-devel] CompBenchmarks++/libcompbenchmarks/UI UI-Console.cpp, NONE, 1.1 UI-Console.h, NONE, 1.1 UI-Msg.cpp, NONE, 1.1 UI-Msg.h, NONE, 1.1