(file) Return to XmlWriter.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlWriter.cpp between version 1.57 and 1.69

version 1.57, 2002/05/15 20:04:10 version 1.69, 2002/08/05 16:14:41
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
 // The Open Group, Tivoli Systems // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
Line 26 
Line 26 
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com) //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 235 
Line 237 
  
 void XmlWriter::append(Array<Sint8>& out, const String& str) void XmlWriter::append(Array<Sint8>& out, const String& str)
 { {
     const Char16* tmp = str.getData();      for (Uint32 i = 0; i < str.size(); i++)
       {
     while (*tmp)          _appendChar(out, str[i]);
         _appendChar(out, *tmp++);      }
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x) void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
Line 265 
Line 267 
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str) void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
 { {
     const Char16* tmp = str.getData();      for (Uint32 i = 0; i < str.size(); i++)
       {
     while (*tmp)          _appendSpecialChar(out, str[i]);
         _appendSpecialChar(out, *tmp++);      }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 345 
Line 347 
  
 void XmlWriter::appendInstanceNameElement( void XmlWriter::appendInstanceNameElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instanceName)      const CIMObjectPath& instanceName)
 { {
     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
  
Line 356 
Line 358 
  
         if (keyBindings[i].getType() == KeyBinding::REFERENCE)         if (keyBindings[i].getType() == KeyBinding::REFERENCE)
         {         {
             CIMReference ref = keyBindings[i].getValue();              CIMObjectPath ref = keyBindings[i].getValue();
             appendValueReferenceElement(out, ref, true);             appendValueReferenceElement(out, ref, true);
         }         }
         else {         else {
             out << "<KEYVALUE VALUETYPE=\"";             out << "<KEYVALUE VALUETYPE=\"";
             out << KeyBinding::typeToString(keyBindings[i].getType());              out << keyBindingTypeToString(keyBindings[i].getType());
             out << "\">";             out << "\">";
  
             // fixed the special character problem - Markus             // fixed the special character problem - Markus
Line 384 
Line 386 
  
 void XmlWriter::appendClassPathElement( void XmlWriter::appendClassPathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& classPath)      const CIMObjectPath& classPath)
 { {
     out << "<CLASSPATH>\n";     out << "<CLASSPATH>\n";
     appendNameSpacePathElement(out,     appendNameSpacePathElement(out,
Line 404 
Line 406 
  
 void XmlWriter::appendInstancePathElement( void XmlWriter::appendInstancePathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instancePath)      const CIMObjectPath& instancePath)
 { {
     out << "<INSTANCEPATH>\n";     out << "<INSTANCEPATH>\n";
     appendNameSpacePathElement(out,     appendNameSpacePathElement(out,
Line 424 
Line 426 
  
 void XmlWriter::appendLocalClassPathElement( void XmlWriter::appendLocalClassPathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& classPath)      const CIMObjectPath& classPath)
 { {
     out << "<LOCALCLASSPATH>\n";     out << "<LOCALCLASSPATH>\n";
     appendLocalNameSpacePathElement(out, classPath.getNameSpace());     appendLocalNameSpacePathElement(out, classPath.getNameSpace());
Line 442 
Line 444 
  
 void XmlWriter::appendLocalInstancePathElement( void XmlWriter::appendLocalInstancePathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instancePath)      const CIMObjectPath& instancePath)
 { {
     out << "<LOCALINSTANCEPATH>\n";     out << "<LOCALINSTANCEPATH>\n";
     appendLocalNameSpacePathElement(out, instancePath.getNameSpace());     appendLocalNameSpacePathElement(out, instancePath.getNameSpace());
Line 461 
Line 463 
  
 void XmlWriter::appendLocalObjectPathElement( void XmlWriter::appendLocalObjectPathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& objectPath)      const CIMObjectPath& objectPath)
 { {
     if (objectPath.isInstanceName())      //
       //  ATTN-CAKG-P2-20020726:  The following condition does not correctly
       //  distinguish instanceNames from classNames in every case
       //  The instanceName of a singleton instance of a keyless class has no
       //  key bindings
       //
       if (objectPath.getKeyBindings ().size () != 0)
     {     {
         appendLocalInstancePathElement(out, objectPath);         appendLocalInstancePathElement(out, objectPath);
     }     }
Line 549 
Line 557 
     out << x.getString();  //ATTN: append() method?     out << x.getString();  //ATTN: append() method?
 } }
  
 inline void _appendValue(Array<Sint8>& out, const CIMReference& x)  inline void _appendValue(Array<Sint8>& out, const CIMObjectPath& x)
 { {
     XmlWriter::appendValueReferenceElement(out, x, true);     XmlWriter::appendValueReferenceElement(out, x, true);
 } }
  
 void _appendValueArray(Array<Sint8>& out, const CIMReference* p, Uint32 size)  void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)
 { {
     out << "<VALUE.REFARRAY>\n";     out << "<VALUE.REFARRAY>\n";
     while (size--)     while (size--)
Line 604 
Line 612 
     {     {
         switch (value.getType())         switch (value.getType())
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             {             {
                 Array<Boolean> a;                 Array<Boolean> a;
                 value.get(a);                 value.get(a);
Line 612 
Line 620 
                 break;                 break;
             }             }
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
             {             {
                 Array<Uint8> a;                 Array<Uint8> a;
                 value.get(a);                 value.get(a);
Line 620 
Line 628 
                 break;                 break;
             }             }
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
             {             {
                 Array<Sint8> a;                 Array<Sint8> a;
                 value.get(a);                 value.get(a);
Line 628 
Line 636 
                 break;                 break;
             }             }
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
             {             {
                 Array<Uint16> a;                 Array<Uint16> a;
                 value.get(a);                 value.get(a);
Line 636 
Line 644 
                 break;                 break;
             }             }
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
             {             {
                 Array<Sint16> a;                 Array<Sint16> a;
                 value.get(a);                 value.get(a);
Line 644 
Line 652 
                 break;                 break;
             }             }
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
             {             {
                 Array<Uint32> a;                 Array<Uint32> a;
                 value.get(a);                 value.get(a);
Line 652 
Line 660 
                 break;                 break;
             }             }
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
             {             {
                 Array<Sint32> a;                 Array<Sint32> a;
                 value.get(a);                 value.get(a);
Line 660 
Line 668 
                 break;                 break;
             }             }
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
             {             {
                 Array<Uint64> a;                 Array<Uint64> a;
                 value.get(a);                 value.get(a);
Line 668 
Line 676 
                 break;                 break;
             }             }
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
             {             {
                 Array<Sint64> a;                 Array<Sint64> a;
                 value.get(a);                 value.get(a);
Line 676 
Line 684 
                 break;                 break;
             }             }
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
             {             {
                 Array<Real32> a;                 Array<Real32> a;
                 value.get(a);                 value.get(a);
Line 684 
Line 692 
                 break;                 break;
             }             }
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
             {             {
                 Array<Real64> a;                 Array<Real64> a;
                 value.get(a);                 value.get(a);
Line 692 
Line 700 
                 break;                 break;
             }             }
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
             {             {
                 Array<Char16> a;                 Array<Char16> a;
                 value.get(a);                 value.get(a);
Line 700 
Line 708 
                 break;                 break;
             }             }
  
             case CIMType::STRING:              case CIMTYPE_STRING:
             {             {
                 Array<String> a;                 Array<String> a;
                 value.get(a);                 value.get(a);
Line 708 
Line 716 
                 break;                 break;
             }             }
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
             {             {
                 Array<CIMDateTime> a;                 Array<CIMDateTime> a;
                 value.get(a);                 value.get(a);
Line 716 
Line 724 
                 break;                 break;
             }             }
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
             {             {
                 Array<CIMReference> a;                  Array<CIMObjectPath> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                 _appendValueArray(out, a.getData(), a.size());
                 break;                 break;
Line 728 
Line 736 
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
         }         }
     }     }
     else if (value.getType() == CIMType::REFERENCE)      else if (value.getType() == CIMTYPE_REFERENCE)
     {     {
         // Has to be separate because it uses VALUE.REFERENCE tag         // Has to be separate because it uses VALUE.REFERENCE tag
         CIMReference v;          CIMObjectPath v;
         value.get(v);         value.get(v);
         _appendValue(out, v);         _appendValue(out, v);
     }     }
Line 741 
Line 749 
  
         switch (value.getType())         switch (value.getType())
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             {             {
                 Boolean v;                 Boolean v;
                 value.get(v);                 value.get(v);
Line 749 
Line 757 
                 break;                 break;
             }             }
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
             {             {
                 Uint8 v;                 Uint8 v;
                 value.get(v);                 value.get(v);
Line 757 
Line 765 
                 break;                 break;
             }             }
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
             {             {
                 Sint8 v;                 Sint8 v;
                 value.get(v);                 value.get(v);
Line 765 
Line 773 
                 break;                 break;
             }             }
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
             {             {
                 Uint16 v;                 Uint16 v;
                 value.get(v);                 value.get(v);
Line 773 
Line 781 
                 break;                 break;
             }             }
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
             {             {
                 Sint16 v;                 Sint16 v;
                 value.get(v);                 value.get(v);
Line 781 
Line 789 
                 break;                 break;
             }             }
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
             {             {
                 Uint32 v;                 Uint32 v;
                 value.get(v);                 value.get(v);
Line 789 
Line 797 
                 break;                 break;
             }             }
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
             {             {
                 Sint32 v;                 Sint32 v;
                 value.get(v);                 value.get(v);
Line 797 
Line 805 
                 break;                 break;
             }             }
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
             {             {
                 Uint64 v;                 Uint64 v;
                 value.get(v);                 value.get(v);
Line 805 
Line 813 
                 break;                 break;
             }             }
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
             {             {
                 Sint64 v;                 Sint64 v;
                 value.get(v);                 value.get(v);
Line 813 
Line 821 
                 break;                 break;
             }             }
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
             {             {
                 Real32 v;                 Real32 v;
                 value.get(v);                 value.get(v);
Line 821 
Line 829 
                 break;                 break;
             }             }
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
             {             {
                 Real64 v;                 Real64 v;
                 value.get(v);                 value.get(v);
Line 829 
Line 837 
                 break;                 break;
             }             }
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
             {             {
                 Char16 v;                 Char16 v;
                 value.get(v);                 value.get(v);
Line 837 
Line 845 
                 break;                 break;
             }             }
  
             case CIMType::STRING:              case CIMTYPE_STRING:
             {             {
                 String v;                 String v;
                 value.get(v);                 value.get(v);
Line 845 
Line 853 
                 break;                 break;
             }             }
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
             {             {
                 CIMDateTime v;                 CIMDateTime v;
                 value.get(v);                 value.get(v);
Line 882 
Line 890 
  
 void XmlWriter::appendValueObjectWithPathElement( void XmlWriter::appendValueObjectWithPathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMObjectWithPath& objectWithPath)      const CIMObject& objectWithPath)
 { {
     out << "<VALUE.OBJECTWITHPATH>\n";     out << "<VALUE.OBJECTWITHPATH>\n";
  
     appendValueReferenceElement(out, objectWithPath.getReference(), false);      appendValueReferenceElement(out, objectWithPath.getPath (), false);
     appendObjectElement(out, objectWithPath.getObject());      appendObjectElement(out, objectWithPath);
  
     out << "</VALUE.OBJECTWITHPATH>\n";     out << "</VALUE.OBJECTWITHPATH>\n";
 } }
Line 904 
Line 912 
  
 void XmlWriter::appendValueReferenceElement( void XmlWriter::appendValueReferenceElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& reference,      const CIMObjectPath& reference,
     Boolean putValueWrapper)     Boolean putValueWrapper)
 { {
     if (putValueWrapper)     if (putValueWrapper)
Line 912 
Line 920 
  
     // See if it is a class or instance reference (instance references have     // See if it is a class or instance reference (instance references have
     // key-bindings; class references do not).     // key-bindings; class references do not).
       //
       //  ATTN-CAKG-P2-20020726:  The following condition does not correctly
       //  distinguish instanceNames from classNames in every case
       //  The instanceName of a singleton instance of a keyless class has no
       //  key bindings
       //
   
       KeyBindingArray kbs = reference.getKeyBindings();
  
     KeyBindingArray kbs = reference.getKeyBindingArray();  
     if (kbs.size())     if (kbs.size())
     {     {
         if (reference.getHost().size())         if (reference.getHost().size())
         {         {
             appendInstancePathElement(out, reference);             appendInstancePathElement(out, reference);
         }         }
         else if (reference.getNameSpace().size())          else if (!reference.getNameSpace().isNull())
         {         {
             appendLocalInstancePathElement(out, reference);             appendLocalInstancePathElement(out, reference);
         }         }
Line 935 
Line 950 
         {         {
             appendClassPathElement(out, reference);             appendClassPathElement(out, reference);
         }         }
         else if (reference.getNameSpace().size())          else if (!reference.getNameSpace().isNull())
         {         {
             appendLocalClassPathElement(out, reference);             appendLocalClassPathElement(out, reference);
         }         }
Line 950 
Line 965 
 } }
  
 void XmlWriter::printValueReferenceElement( void XmlWriter::printValueReferenceElement(
     const CIMReference& reference,      const CIMObjectPath& reference,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;     Array<Sint8> tmp;
Line 969 
Line 984 
  
 void XmlWriter::appendValueNamedInstanceElement( void XmlWriter::appendValueNamedInstanceElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMNamedInstance& namedInstance)      const CIMInstance& namedInstance)
 { {
     out << "<VALUE.NAMEDINSTANCE>\n";     out << "<VALUE.NAMEDINSTANCE>\n";
  
     appendInstanceNameElement(out, namedInstance.getInstanceName());      appendInstanceNameElement(out, namedInstance.getPath ());
     appendInstanceElement(out, namedInstance.getInstance());      appendInstanceElement(out, namedInstance);
  
     out << "</VALUE.NAMEDINSTANCE>\n";     out << "</VALUE.NAMEDINSTANCE>\n";
 } }
Line 1315 
Line 1330 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // appendScopeElement()
   //
   //     <!ELEMENT SCOPE EMPTY>
   //     <!ATTLIST SCOPE
   //              CLASS        (true|false)      'false'
   //              ASSOCIATION  (true|false)      'false'
   //              REFERENCE    (true|false)      'false'
   //              PROPERTY     (true|false)      'false'
   //              METHOD       (true|false)      'false'
   //              PARAMETER    (true|false)      'false'
   //              INDICATION   (true|false)      'false'>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendScopeElement(
       Array<Sint8>& out,
       const CIMScope & scope)
   {
       if (!(scope.equal (CIMScope ())))
       {
           out << "<SCOPE";
   
           if (scope.hasScope (CIMScope::CLASS))
               out << " CLASS=\"true\"";
   
           if (scope.hasScope (CIMScope::ASSOCIATION))
               out << " ASSOCIATION=\"true\"";
   
           if (scope.hasScope (CIMScope::REFERENCE))
               out << " REFERENCE=\"true\"";
   
           if (scope.hasScope (CIMScope::PROPERTY))
               out << " PROPERTY=\"true\"";
   
           if (scope.hasScope (CIMScope::METHOD))
               out << " METHOD=\"true\"";
   
           if (scope.hasScope (CIMScope::PARAMETER))
               out << " PARAMETER=\"true\"";
   
           if (scope.hasScope (CIMScope::INDICATION))
               out << " INDICATION=\"true\"";
   
           out << "/>";
       }
   }
   
   //------------------------------------------------------------------------------
   //
 // appendMethodCallHeader() // appendMethodCallHeader()
 // //
 //     Build HTTP method call request header. //     Build HTTP method call request header.
Line 1673 
Line 1737 
     out << "<RETURNVALUE";     out << "<RETURNVALUE";
  
     CIMType type = value.getType();     CIMType type = value.getType();
     if (type != CIMType::NONE)      if (type != CIMTYPE_NONE)
     {     {
         out << " PARAMTYPE=\"" << type.toString() << "\"";          out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";
     }     }
  
     out << ">\n";     out << ">\n";
Line 1794 
Line 1858 
 void XmlWriter::appendInstanceNameIParameter( void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const CIMReference& instanceName)      const CIMObjectPath& instanceName)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     appendInstanceNameElement(out, instanceName);     appendInstanceNameElement(out, instanceName);
Line 1804 
Line 1868 
 void XmlWriter::appendObjectNameIParameter( void XmlWriter::appendObjectNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const CIMReference& objectName)      const CIMObjectPath& objectName)
 { {
     if (objectName.isClassName())      //
       //  ATTN-CAKG-P2-20020726:  The following condition does not correctly
       //  distinguish instanceNames from classNames in every case
       //  The instanceName of a singleton instance of a keyless class also
       //  has no key bindings
       //
       if (objectName.getKeyBindings ().size () == 0)
     {     {
         XmlWriter::appendClassNameIParameter(         XmlWriter::appendClassNameIParameter(
             out, name, objectName.getClassName());             out, name, objectName.getClassName());
Line 1859 
Line 1929 
 void XmlWriter::appendNamedInstanceIParameter( void XmlWriter::appendNamedInstanceIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const CIMNamedInstance& namedInstance)      const CIMInstance& namedInstance)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     appendValueNamedInstanceElement(out, namedInstance);     appendValueNamedInstanceElement(out, namedInstance);
Line 1914 
Line 1984 
     _appendIParamValueElementBegin(out, "PropertyList");     _appendIParamValueElementBegin(out, "PropertyList");
  
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
     for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)      for (Uint32 i = 0; i < propertyList.size(); i++)
     {     {
         out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";          out << "<VALUE>" << propertyList[i] << "</VALUE>\n";
     }     }
     out << "</VALUE.ARRAY>\n";     out << "</VALUE.ARRAY>\n";
  
Line 1967 
Line 2037 
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage( Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const String& nameSpace,     const String& nameSpace,
     const CIMReference& path,      const CIMObjectPath& path,
     const char* methodName,     const char* methodName,
     const Array<CIMParamValue>& parameters,     const Array<CIMParamValue>& parameters,
     const String& messageId,     const String& messageId,
Line 1975 
Line 2045 
 { {
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
     CIMReference localObjectPath = path;      CIMObjectPath localObjectPath = path;
     localObjectPath.setNameSpace(nameSpace);     localObjectPath.setNameSpace(nameSpace);
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
Line 2562 
Line 2632 
     return buffer;     return buffer;
 } }
  
   //------------------------------------------------------------------------------
   //
   // XmlWriter::keyBindingTypeToString
   //
   //------------------------------------------------------------------------------
   const char* XmlWriter::keyBindingTypeToString (KeyBinding::Type type)
   {
       switch (type)
       {
           case KeyBinding::BOOLEAN:
               return "boolean";
   
           case KeyBinding::STRING:
               return "string";
   
           case KeyBinding::NUMERIC:
               return "numeric";
   
           case KeyBinding::REFERENCE:
           default:
               PEGASUS_ASSERT(false);
       }
   
       return "unknown";
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.57  
changed lines
  Added in v.1.69
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2