ippStringBuilder.h

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. 
#pragma once
#include "ippdme/ippdme.h"
#include "ippdme/ippChangeToolActionType.h"
#include "ippdme/ippErrorNameType.h"
#include "ippdme/ippCoordSysType.h"
#include "ippdme/ippCommandNameType.h"
#include "ippdme/ippMachineClassType.h"

#include <string>
class ippTag;
class ippTargetVector;

class IPPDME_EXT_CLASS ippStringBuilder
{
public:
  ippStringBuilder();
  
  // construct a string for a response string
  ippStringBuilder(const ippTag& tag,const char* marker);

  // construct a string for a command string
  ippStringBuilder(const ippTag& tag);

  // destructor
  virtual ~ippStringBuilder();

  // --- generic 
  void Append(const char*);


  std::string ToString() const;

  // ---- i++ specfic
  void StartFunc(const char* funcName);
  void StartFunc(ippCommandNameType type);

  void EndFunc();
  // str.StartFunc("G"); str.EndFunc(); produces : G();

  void AppendParam(int value);
  void AppendParam(double value);
  void AppendParam(const char* value);
  void AppendParam(const std::string& value){AppendParam(value.c_str());}
  void AppendParam(ippChangeToolActionType);
  void AppendParam(const ippErrorNameType& value);
  void AppendParam(ippCoordSysType value);
  void AppendParam(ippMachineClassType value);

  ippStringBuilder& AppendFunc(const char*function_name,const char* value);
  ippStringBuilder& AppendFunc(const char*function_name,const std::string& value){ return AppendFunc(function_name,value.c_str()); }
  ippStringBuilder& AppendFunc(const char*function_name,double value);
  ippStringBuilder& AppendFunc(const char*function_name,int value);
  ippStringBuilder& AppendFunc(const char*function_name,double v1,double v2,double v3);
  ippStringBuilder& AppendFunc(const char*function_name);
  ippStringBuilder& AppendFunc(const char*function_name,const ippErrorNameType&);
  ippStringBuilder& AppendFunc(const char*function_name,const ippTargetVector& v);
  ippStringBuilder& AppendFunc(const char*function_name,ippCoordSysType v);
  ippStringBuilder& AppendFunc(const char*function_name,ippMachineClassType v);
  
 
  // str.StartFunc("G"); str.AppendParam("F",1.0); str.AppendParam("F",1.0);
  // str.EndFunc(); produces : G(F(1.0),F(1.0))
private:
  //
  char* _buffer;
  char* _cur;
  std::vector<int> _stack;
  //----
  ippStringBuilder(const ippStringBuilder&);
  void operator=(const ippStringBuilder&);
  void init();
  void new_argument();

};

---