ippStringBuilder.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
#include "stdafx.h"
#include "ippdme/misc/ippStringBuilder.h"
#include "ippdme/ippTag.h"
#include "ippdme/ippTargetVector.h"
#include "ippdme/assert.h"

ippStringBuilder::ippStringBuilder()
{
  init();
}

void ippStringBuilder::init()
{
  _buffer=new char[65535];
  _cur = _buffer;
  _stack.push_back(0);
}

ippStringBuilder::ippStringBuilder(
 const ippTag& tag,
 char const * marker
)
{
  init();
  int k = sprintf(_cur,"%s %1s ",tag.getTagString().c_str(),marker);
  _cur+=k;
}

ippStringBuilder::ippStringBuilder(
 const ippTag& tag
)
{
  init();
  int k = sprintf(_cur,"%s ",tag.getTagString().c_str());
  _cur+=k;
}

ippStringBuilder::~ippStringBuilder()
{
  delete [] _buffer;
  _buffer =0;
  _cur = 0;
}

/* !ippStringBuilder::Append
 * append text verbatim to the string.
 *
 */
void ippStringBuilder::Append(const char * text)
{
  int k = sprintf(_cur,"%s",text);
  _cur+=k;
}

void ippStringBuilder::StartFunc(const char* func_name)
{
  new_argument();
  int k = sprintf(_cur,"%s(",func_name);
  _cur+=k;
  _stack.push_back(0);
}
void ippStringBuilder::StartFunc(ippCommandNameType type)
{
  StartFunc(getCommandNameString(type));
}

void ippStringBuilder::EndFunc()
{
  IPP_ASSERT(_stack.size()>0);
  Append(")");
  _stack.pop_back();
}

void ippStringBuilder::new_argument()
{
  if(_stack.size()==0) return;
  if(_stack.back() >0) { 
    Append(", ");
  }
  _stack.back()++;
}

void ippStringBuilder::AppendParam(double value)
{
  new_argument();

  int k = sprintf(_cur,"%.5lG",value); 
  char* ptr=_cur;
  while (*ptr!=0 && *ptr!='.' && *ptr!='E'){
    ptr++;
  }
  if (*ptr !='.' && *ptr !='E') {
    *ptr++='.';
    *ptr++=0;
  }        
  _cur+=strlen(_cur);

}

 
void ippStringBuilder::AppendParam( ippChangeToolActionType value)
{
  new_argument();
  int k = sprintf(_cur,"%s",toString(value));
  _cur+=k;
}
void ippStringBuilder::AppendParam( ippCoordSysType value)
{
  new_argument();
  int k = sprintf(_cur,"%s",toString(value));
  _cur+=k;
}
void ippStringBuilder::AppendParam( ippMachineClassType value)
{
  new_argument();
  int k = sprintf(_cur,"%s",toString(value));
  _cur+=k;
}
void ippStringBuilder::AppendParam( const ippErrorNameType& value)
{
  new_argument();
  int k = sprintf(_cur,"%04d",value.asInteger());
  _cur+=k;
}


void ippStringBuilder::AppendParam(int value)
{
  new_argument();
  int k = sprintf(_cur,"%d",value);
  _cur+=k;
}
void ippStringBuilder::AppendParam(const char* value)
{
  new_argument();
  int k = sprintf(_cur,"\"%s\"",value);
  _cur+=k;
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char* param_name,double value)
{
  StartFunc(param_name);
    AppendParam(value);
  EndFunc();
  return *this;
}
ippStringBuilder& ippStringBuilder::AppendFunc(const char* param_name,int value)
{
  StartFunc(param_name);
    AppendParam(value);
  EndFunc();
  return *this;
}
ippStringBuilder& ippStringBuilder::AppendFunc(const char* func_name,const char* value)
{
  StartFunc(func_name);
    AppendParam(value);
  EndFunc();
  return *this;
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char* func_name,double v1,double v2,double v3)
{
  StartFunc(func_name);
    AppendParam(v1);
    AppendParam(v2);
    AppendParam(v3);
  EndFunc();
  return *this;
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char* func_name,const ippTargetVector& v)
{
  return AppendFunc(func_name,v.getI(),v.getJ(),v.getK());
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char* func_name,const ippErrorNameType& value)
{
  StartFunc(func_name);
    AppendParam(value);
  EndFunc();
  return *this;
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char*func_name,ippMachineClassType value)
{
  StartFunc(func_name);
    AppendParam(value);
  EndFunc();
  return *this;
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char* func_name,ippCoordSysType value)
{
  StartFunc(func_name);
    AppendParam(value);
  EndFunc();
  return *this;
}

ippStringBuilder& ippStringBuilder::AppendFunc(const char* func_name)
{
  StartFunc(func_name);
  EndFunc();
  return *this;
}

std::string ippStringBuilder::ToString() const
{
  IPP_ASSERT(_stack.size()==1);
  // add the final 13 /10 characters
  int k = sprintf(_cur,"%c%c",13,10);
  return _buffer;
}

---