CStringArrayparam.cpp

Go to the documentation of this file.

#include "CStringArrayparam.h"                                  
#include <TCLInterpreter.h>
#include <TCLResult.h>
#include <TCLList.h>
#include <vector>
#include <RangeError.h>
#include <stdio.h>

CStringArrayparam::CStringArrayparam (const string& rKey, int nSize)
   : CConfigurationParameter(rKey), 
   m_aStrings(0),
   m_nSize(nSize)
{   
    m_aStrings = new string[m_nSize];
} 
 CStringArrayparam::~CStringArrayparam ( )  //Destructor - Delete dynamic objects
{
    delete []m_aStrings;
}
CStringArrayparam::CStringArrayparam (const CStringArrayparam& rhs ) 
  : CConfigurationParameter (rhs),
  m_nSize(rhs.m_nSize)
 
{
    m_aStrings = new string[m_nSize];
    for(int i =0; i < m_nSize; i++) {
        m_aStrings[i] = rhs.m_aStrings[i];
    }
} 
CStringArrayparam& 
CStringArrayparam::operator= (const CStringArrayparam& rhs)
{ 
    if (this == &rhs) {
        delete []m_aStrings;
        m_nSize     = rhs.m_nSize;
        m_aStrings = new string[m_nSize]; 
    }
    return *this;
}
int 
CStringArrayparam::operator== (const CStringArrayparam& rhs) const
{ 

    if(!CConfigurationParameter::operator==(rhs)) return 0;
    if(m_nSize != rhs.m_nSize) return 0;
    for(int i =0; i < m_nSize; i++) {
        if(m_aStrings[i] != rhs.m_aStrings[i]) return 0;
    }
    return 1;                      // Equality!.
}

// Functions for class CStringArrayparam

string& 
CStringArrayparam::operator[](int n)  
{
     if((n < 0) || (n >= m_nSize)) {
       CRangeError r(0, m_nSize-1, n,
                     string("CStringArrayParam::operator[] bad index"));
       throw r;
     }
     return m_aStrings[n]; 
}  

int 
CStringArrayparam::SetValue(CTCLInterpreter& rInterp, 
                            CTCLResult& rResult, 
                            const char* pValue)
{ 
    // First throw things up into a list and then split the list into a string vector:
    
    StringArray Values;
    try {
        CTCLList ValueList(&rInterp, pValue);
        ValueList.Split(Values);
    }
    catch(...) {
        rResult += "Configuration string array: ";
        rResult += getSwitch();
        rResult += " configuration list was badly formatted.";
        rResult += pValue;
        return TCL_ERROR;
    }
    
    // The size of the vector should be the same as the size of the
    // m_aStrings array:
    
    if(Values.size() != m_nSize) {
        rResult += "Configuration string array: ";
        rResult += " Size mismatch between the parameter list and \n";
        rResult +=  "the list. ";
        rResult += getSwitch();
        return TCL_ERROR;
    }
        
    // Copy the string vector into the string array:
    
    for(int i =0; i < m_nSize; i++) {
        m_aStrings[i] = Values[i];
    }
    return TCL_OK;
}
string
CStringArrayparam::GetParameterFormat()
{
    char result[100];
    sprintf(result, "string[%d]", m_nSize);
    return string(result);
}

---