valuefactory.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

  CIMObjectPath cop(rep);                     
  AutoPtr<CIMValue> v( new CIMValue(cop) );
  return v.release();
}




// ------------------------------------------------------------------
// When the value to be build is of Array type, this routine
// parses out the comma-separated values and builds the array
// ----------------------------------------------------------------- 
static
CIMValue *
build_array_value(CIMType type, unsigned int arrayDimension,
		  const String &rep)
{
  String sval;
  Uint32 start = 0;
  Uint32 strsize = rep.size();
  Uint32 end = strsize;

  /* KS Changed all of the following from whil {...} to do {...} while (start < end);
  The combination of the testing and nexcsv meant the last entry was not processed.
  */
  switch (type) {
  case CIMTYPE_BOOLEAN: {
    Array<Boolean> *a = new Array<Boolean>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            if (sval[0] == 'T')
                a->append(1);
            else
                a->append(0);
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_UINT8: {
    Array<Uint8> *a = new Array<Uint8>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Uint8)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_SINT8: {
    Array<Sint8> *a = new Array<Sint8>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Sint8)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_UINT16: {
    Array<Uint16> *a = new Array<Uint16>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Uint16)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_SINT16: {
    Array<Sint16> *a = new Array<Sint16>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Sint16)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_UINT32: {
    Array<Uint32> *a = new Array<Uint32>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Uint32)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_SINT32: {
    Array<Sint32> *a = new Array<Sint32>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Sint32)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_UINT64: {
    Array<Uint64> *a = new Array<Uint64>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Uint64)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_SINT64: {
    Array<Sint64> *a = new Array<Sint64>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Sint64)valueFactory::Stoi(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_REAL32: {
    Array<Real32> *a = new Array<Real32>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
        a->append((Real32)Stof(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_REAL64: {
    Array<Real64> *a = new Array<Real64>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append((Real64)Stof(sval));
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_CHAR16: {
    Array<Char16> *a = new Array<Char16>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append(sval[0]);
        } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_STRING: {
    Array<String> *a = new Array<String>;
    if (strsize != 0){
        do{
            start = nextcsv(rep, ',', start, end, sval);
            a->append(sval);
         } while (start < end);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_DATETIME: {
    Array<CIMDateTime> *a = new Array<CIMDateTime>;
    while (strsize && (start = nextcsv(rep, ',', start, end, sval)) < end ) {
      CIMDateTime dt;
      StoDT(sval, dt);
      a->append(dt);
    }
    return new CIMValue(*a);
  }
  case CIMTYPE_REFERENCE:
    break;
//  PEP 194:
//  Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
//  Pegasus internal representation of an embedded object, so it won't be found here.
  case CIMTYPE_OBJECT:
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  case CIMTYPE_INSTANCE:
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
    break;
  }  // end switch
  return 0;
}

/* ATTN: KS 20 Feb 02 - Think we need to account for NULL value here differently
   They come in as an empty string from devaultValue and if they are an empty 
   string we need to create the correct type but without a value in it.
   Easiest may be to test in each converter since otherwise would have to 
   create a second switch. Either that or if strlength = zero
   create an empty CIMValue and then put in the type
                CIMValue x;
            x.set(Uint16(9)
*/
//----------------------------------------------------------------
CIMValue *
valueFactory::createValue(CIMType type, int arrayDimension,
                          Boolean isNULL,
			  const String *repp)
{
  const String &rep = *repp;
  //cout << "valueFactory, value = " << rep << endl;
  CIMDateTime dt;
  if (arrayDimension == -1) { // this is not an array type
      
    if (isNULL)
    {
       return new CIMValue(type, false);
    }

    switch(type) {
    case CIMTYPE_UINT8:    return new CIMValue((Uint8)  valueFactory::Stoi(rep));
    case CIMTYPE_SINT8:    return new CIMValue((Sint8)  valueFactory::Stoi(rep));
    case CIMTYPE_UINT16:   return new CIMValue((Uint16) valueFactory::Stoi(rep));
    case CIMTYPE_SINT16:   return new CIMValue((Sint16) valueFactory::Stoi(rep));
    case CIMTYPE_UINT32:   return new CIMValue((Uint32) valueFactory::Stoi(rep));
    case CIMTYPE_SINT32:   return new CIMValue((Sint32) valueFactory::Stoi(rep));
    case CIMTYPE_UINT64:   return new CIMValue((Uint64) valueFactory::Stoi(rep));
    case CIMTYPE_SINT64:   return new CIMValue((Sint64) valueFactory::Stoi(rep));
    case CIMTYPE_REAL32:   return new CIMValue((Real32) Stof(rep));
    case CIMTYPE_REAL64:   return new CIMValue((Real64) Stof(rep));
    case CIMTYPE_CHAR16:   return new CIMValue((Char16) rep[0]);
    case CIMTYPE_BOOLEAN:  return new CIMValue((Boolean) (rep[0] == 'T'?1:0));
    case CIMTYPE_STRING:   return new CIMValue(rep);
    case CIMTYPE_DATETIME: return new CIMValue(StoDT(rep, dt));
    case CIMTYPE_REFERENCE: return build_reference_value(rep);
//  PEP 194:
//  Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
//  Pegasus internal representation of an embedded object, so it won't be found here.
    case CIMTYPE_OBJECT:
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
    case CIMTYPE_INSTANCE:
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
        break;
    }
    return(new CIMValue((Uint32) 0));    // default
  } else { // an array type, either fixed or variable

  const String &rep = *repp;
      // KS If empty string set CIMValue type but Null attribute.
      if (isNULL)
          return new CIMValue(type, true, arrayDimension);

    return build_array_value(type, (unsigned int)arrayDimension, rep);
  }
}