(file) Return to MemoryResidentRepository.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Repository / Attic

Diff for /pegasus/src/Pegasus/Repository/Attic/MemoryResidentRepository.cpp between version 1.1.2.3 and 1.1.2.5

version 1.1.2.3, 2007/10/06 00:38:22 version 1.1.2.5, 2007/11/03 22:42:34
Line 51 
Line 51 
 // //
 //============================================================================== //==============================================================================
  
 PEGASUS_FORMAT(2, 3)  class ThrowContext
 static void _throw(CIMStatusCode code, const char* format, ...)  
 { {
     char buffer[4096];  public:
  
       PEGASUS_FORMAT(3, 4)
       ThrowContext(CIMStatusCode code_, const char* format, ...) : code(code_)
       {
           char buffer[1024];
     va_list ap;     va_list ap;
     va_start(ap, format);     va_start(ap, format);
     vsprintf(buffer, format, ap);     vsprintf(buffer, format, ap);
     va_end(ap);     va_end(ap);
     throw CIMException(code, buffer);          msg = buffer;
 } }
       CIMStatusCode code;
       String msg;
   };
   
   #define Throw(ARGS) \
       do \
       { \
           ThrowContext c ARGS; \
           throw CIMException(c.code, c.msg); \
       } \
       while (0)
  
 class Str class Str
 { {
Line 111 
Line 125 
  
             if (!mf)             if (!mf)
             {             {
                 _throw(CIM_ERR_NOT_FOUND,                  Throw((CIM_ERR_NOT_FOUND,
                     "modifyInstance() failed: unknown property: %s",                     "modifyInstance() failed: unknown property: %s",
                     *Str(cp.getName()));                      *Str(cp.getName())));
             }             }
  
             // Reject attempts to modify key properties:             // Reject attempts to modify key properties:
  
             if (mf->flags & META_FLAG_KEY)             if (mf->flags & META_FLAG_KEY)
             {             {
                 _throw(CIM_ERR_FAILED,                  Throw((CIM_ERR_FAILED,
                     "modifyInstance() failed to modify key property: %s",                     "modifyInstance() failed to modify key property: %s",
                     *Str(cp.getName()));                      *Str(cp.getName())));
             }             }
  
             // Add or replace property in result instance:             // Add or replace property in result instance:
Line 148 
Line 162 
 // //
 //============================================================================== //==============================================================================
  
 static void (*_saveHandler)(const Buffer& buffer);  static void (*_saveCallback)(const Buffer& buffer, void* data);
 static void (*_loadHandler)(Buffer& buffer);  static void* _saveData;
   static void (*_loadCallback)(Buffer& buffer, void* data);
   static void* _loadData;
  
 MemoryResidentRepository::MemoryResidentRepository( MemoryResidentRepository::MemoryResidentRepository(
     const String& repositoryRoot,     const String& repositoryRoot,
Line 195 
Line 211 
     Uint32 pos = _findInstance(nameSpace, instanceName);     Uint32 pos = _findInstance(nameSpace, instanceName);
  
     if (pos == PEG_NOT_FOUND)     if (pos == PEG_NOT_FOUND)
         _throw(CIM_ERR_NOT_FOUND, "%s", *Str(instanceName));          Throw((CIM_ERR_NOT_FOUND, "%s", *Str(instanceName)));
  
     CIMInstance cimInstance = _rep[pos].second.clone();     CIMInstance cimInstance = _rep[pos].second.clone();
  
Line 227 
Line 243 
     Uint32 pos = _findInstance(nameSpace, instanceName);     Uint32 pos = _findInstance(nameSpace, instanceName);
  
     if (pos == PEG_NOT_FOUND)     if (pos == PEG_NOT_FOUND)
         _throw(CIM_ERR_NOT_FOUND, "%s", *Str(instanceName));          Throw((CIM_ERR_NOT_FOUND, "%s", *Str(instanceName)));
  
     _rep.remove(pos);     _rep.remove(pos);
     _processSaveHandler();     _processSaveHandler();
Line 263 
Line 279 
     // Reject if an instance with this name already exists:     // Reject if an instance with this name already exists:
  
     if (_findInstance(nameSpace, cop) != PEG_NOT_FOUND)     if (_findInstance(nameSpace, cop) != PEG_NOT_FOUND)
         _throw(CIM_ERR_ALREADY_EXISTS, "%s", *Str(cop));          Throw((CIM_ERR_ALREADY_EXISTS, "%s", *Str(cop)));
  
     // Add instance to array:     // Add instance to array:
  
Line 302 
Line 318 
  
     if (!mc)     if (!mc)
     {     {
         _throw(CIM_ERR_FAILED,          Throw((CIM_ERR_FAILED,
             "modifyInstance() failed: unknown class: %s:%s",             "modifyInstance() failed: unknown class: %s:%s",
             *Str(nameSpace), *Str(className));              *Str(nameSpace), *Str(className)));
     }     }
  
     // Get original instance to be modified:     // Get original instance to be modified:
Line 313 
Line 329 
  
     if (pos == PEG_NOT_FOUND)     if (pos == PEG_NOT_FOUND)
     {     {
         _throw(CIM_ERR_NOT_FOUND, "modified() failed: unknown instance: %s",          Throw((CIM_ERR_NOT_FOUND,
             *Str(cop.toString()));              "modifyInstance() failed: unknown instance: %s",
               *Str(cop.toString())));
     }     }
  
     CIMInstance resultInstance = _rep[pos].second.clone();     CIMInstance resultInstance = _rep[pos].second.clone();
Line 495 
Line 512 
     const String& queryLanguage,     const String& queryLanguage,
     const String& query)     const String& query)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "execQuery()");      Throw((CIM_ERR_NOT_SUPPORTED, "execQuery()"));
     return Array<CIMInstance>();     return Array<CIMInstance>();
 } }
  
Line 526 
Line 543 
     }     }
     else     else
     {     {
         _throw(CIM_ERR_NOT_SUPPORTED, "associators()");          Throw((CIM_ERR_NOT_SUPPORTED, "associators()"));
         return Array<CIMObject>();         return Array<CIMObject>();
     }     }
 } }
Line 552 
Line 569 
     }     }
     else     else
     {     {
         _throw(CIM_ERR_NOT_SUPPORTED, "associatorNames()");          Throw((CIM_ERR_NOT_SUPPORTED, "associatorNames()"));
         return Array<CIMObjectPath>();         return Array<CIMObjectPath>();
     }     }
 } }
Line 580 
Line 597 
     }     }
     else     else
     {     {
         _throw(CIM_ERR_NOT_SUPPORTED, "references()");          Throw((CIM_ERR_NOT_SUPPORTED, "references()"));
         return Array<CIMObject>();         return Array<CIMObject>();
     }     }
 } }
Line 602 
Line 619 
     }     }
     else     else
     {     {
         _throw(CIM_ERR_NOT_SUPPORTED, "referenceNames()");          Throw((CIM_ERR_NOT_SUPPORTED, "referenceNames()"));
         return Array<CIMObjectPath>();         return Array<CIMObjectPath>();
     }     }
 } }
Line 613 
Line 630 
     const CIMObjectPath& instanceName,     const CIMObjectPath& instanceName,
     const CIMName& propertyName)     const CIMName& propertyName)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "getProperty()");      Throw((CIM_ERR_NOT_SUPPORTED, "getProperty()"));
     return CIMValue();     return CIMValue();
 } }
  
Line 625 
Line 642 
     const CIMValue& newValue,     const CIMValue& newValue,
     const ContentLanguageList& contentLangs)     const ContentLanguageList& contentLangs)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "setProperty()");      Throw((CIM_ERR_NOT_SUPPORTED, "setProperty()"));
 } }
  
 CIMQualifierDecl MemoryResidentRepository::getQualifier( CIMQualifierDecl MemoryResidentRepository::getQualifier(
Line 702 
Line 719 
     bool lock,     bool lock,
     RepositoryDeclContext* context)     RepositoryDeclContext* context)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "setDeclContext()");      Throw((CIM_ERR_NOT_SUPPORTED, "setDeclContext()"));
 } }
  
 Boolean MemoryResidentRepository::isDefaultInstanceProvider( Boolean MemoryResidentRepository::isDefaultInstanceProvider(
Line 768 
Line 785 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 void MemoryResidentRepository::setSaveHandler(  void MemoryResidentRepository::installSaveCallback(
     void (*handler)(const Buffer& buffer))      void (*handler)(const Buffer& buffer, void* data),
       void * data)
 { {
     _saveHandler = handler;      _saveCallback = handler;
       _saveData = data;
 } }
  
 void MemoryResidentRepository::setLoadHandler(  void MemoryResidentRepository::installLoadCallback(
     void (*handler)(Buffer& buffer))      void (*handler)(Buffer& buffer, void* data),
       void * data)
 { {
     _loadHandler = handler;      _loadCallback = handler;
       _loadData = data;
 } }
  
 void MemoryResidentRepository::_processSaveHandler() void MemoryResidentRepository::_processSaveHandler()
 { {
     if (!_saveHandler)      if (!_saveCallback)
         return;         return;
  
     Buffer out;     Buffer out;
Line 793 
Line 814 
         SerializeInstance(out, _rep[i].second);         SerializeInstance(out, _rep[i].second);
     }     }
  
     (*_saveHandler)(out);      (*_saveCallback)(out, _saveData);
 } }
  
 void MemoryResidentRepository::_processLoadHandler() void MemoryResidentRepository::_processLoadHandler()
 { {
     if (!_loadHandler)      if (!_loadCallback)
         return;         return;
  
     Buffer in;     Buffer in;
     (*_loadHandler)(in);      (*_loadCallback)(in, _loadData);
     size_t pos = 0;     size_t pos = 0;
  
     while (pos != in.size())     while (pos != in.size())
Line 810 
Line 831 
         CIMNamespaceName nameSpace;         CIMNamespaceName nameSpace;
  
         if (DeserializeNameSpace(in, pos, nameSpace) != 0)         if (DeserializeNameSpace(in, pos, nameSpace) != 0)
         {  
             printf("***** DeserializeNameSpace() failed\n");  
             return;             return;
         }  
  
         CIMInstance cimInstance;         CIMInstance cimInstance;
  
         if (DeserializeInstance(in, pos, cimInstance) != 0)         if (DeserializeInstance(in, pos, cimInstance) != 0)
         {  
             printf("***** DeserializeInstance() failed\n");  
             return;             return;
         }  
  
         printf("===== MemoryResidentRepository: loaded instance\n");  
         _rep.append(NamespaceInstancePair(nameSpace, cimInstance));         _rep.append(NamespaceInstancePair(nameSpace, cimInstance));
     }     }
 } }

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