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

Diff for /pegasus/src/Pegasus/Common/OperationContext.cpp between version 1.17 and 1.38.6.3

version 1.17, 2003/04/16 00:17:14 version 1.38.6.3, 2006/11/22 15:21:55
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // 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
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 26 
Line 34 
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
   //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
   //              Terry Martin, Hewlett-Packard Company (terry.martin@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "OperationContext.h" #include "OperationContext.h"
 #include "ArrayInternal.h" #include "ArrayInternal.h"
   #include <Pegasus/Common/MessageLoader.h> //l10n
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 91 
Line 102 
 const OperationContext::Container & OperationContext::get( const OperationContext::Container & OperationContext::get(
     const String& containerName) const     const String& containerName) const
 { {
     for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)      Uint32 size = _rep->containers.size();
     {      Container** data = (Container**)_rep->containers.getData();
         if(containerName == _rep->containers[i]->getName())  
         {  
             Container * p = _rep->containers[i];  
  
             return(*p);      for (; size--; data++)
         }          if (data[0]->getName() == containerName)
     }              return *(data[0]);
   
       static Exception _exception(MessageLoaderParms(
           "Common.OperationContext.OBJECT_NOT_FOUND", "object not found"));
  
     throw Exception("object not found");      throw Exception(_exception);
 } }
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  Boolean OperationContext::contains(
 const OperationContext::Container & OperationContext::get(const Uint32 key) const      const String& containerName) const
 {  
     for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)  
     {  
         if(key == _rep->containers[i]->getKey())  
         {         {
             Container * p = _rep->containers[i];      Uint32 size = _rep->containers.size();
       Container** data = (Container**)_rep->containers.getData();
  
             return(*p);      for (; size--; data++)
         }      {
           if (data[0]->getName() == containerName)
               return true;
     }     }
  
     throw Exception("object not found");      return false;
 } }
 #endif  
  
 void OperationContext::set(const OperationContext::Container & container) void OperationContext::set(const OperationContext::Container & container)
 { {
Line 138 
Line 147 
         }         }
     }     }
  
     throw Exception("object not found");          //l10n
           MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
                                                            "object not found");
       throw Exception(parms);
       //throw Exception("object not found");
 } }
  
 void OperationContext::insert(const OperationContext::Container & container) void OperationContext::insert(const OperationContext::Container & container)
Line 147 
Line 160 
     {     {
         if(container.getName() == _rep->containers[i]->getName())         if(container.getName() == _rep->containers[i]->getName())
         {         {
             throw Exception("object already exists.");                  //l10n
                           MessageLoaderParms parms("Common.OperationContext.OBJECT_ALREADY_EXISTS",
                                                            "object already exists.");
                   throw Exception(parms);
               //throw Exception("object already exists.");
         }         }
     }     }
  
Line 167 
Line 184 
         }         }
     }     }
  
     throw Exception("object not found");          //l10n
           MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
                                                            "object not found");
       throw Exception(parms);
       //throw Exception("object not found");
 } }
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 void OperationContext::remove(const Uint32 key)  
 {  
     for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)  
     {  
         if(key == _rep->containers[i]->getKey())  
         {  
             delete _rep->containers[i];  
             _rep->containers.remove(i);  
   
             return;  
         }  
     }  
   
     throw Exception("object not found");  
 }  
 #endif  
  
 // //
 // OperationContext::Container // OperationContext::Container
 // //
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 OperationContext::Container::Container(const Uint32 key) : _key(key)  
 {  
 }  
 #endif  
   
 OperationContext::Container::~Container(void) OperationContext::Container::~Container(void)
 { {
 } }
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 const Uint32 & OperationContext::Container::getKey(void) const  
 {  
     return(_key);  
 }  
 #endif  
  
 // //
 // IdentityContainer // IdentityContainer
Line 222 
Line 214 
 const String IdentityContainer::NAME = "IdentityContainer"; const String IdentityContainer::NAME = "IdentityContainer";
  
 IdentityContainer::IdentityContainer(const OperationContext::Container & container) IdentityContainer::IdentityContainer(const OperationContext::Container & container)
 #ifndef PEGASUS_REMOVE_DEPRECATED  
     : OperationContext::Container(container.getKey())  
 #endif  
 { {
     const IdentityContainer * p = dynamic_cast<const IdentityContainer *>(&container);     const IdentityContainer * p = dynamic_cast<const IdentityContainer *>(&container);
  
Line 238 
Line 227 
 } }
  
 IdentityContainer::IdentityContainer(const IdentityContainer & container) IdentityContainer::IdentityContainer(const IdentityContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined (PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
 { {
     _rep = new IdentityContainerRep();     _rep = new IdentityContainerRep();
     _rep->userName = container._rep->userName;     _rep->userName = container._rep->userName;
 } }
  
 IdentityContainer::IdentityContainer(const String & userName) IdentityContainer::IdentityContainer(const String & userName)
 #ifndef PEGASUS_REMOVE_DEPRECATED  
     : OperationContext::Container(CONTEXT_IDENTITY)  
 #endif  
 { {
     _rep = new IdentityContainerRep();     _rep = new IdentityContainerRep();
     _rep->userName = userName;     _rep->userName = userName;
Line 290 
Line 279 
     return(_rep->userName);     return(_rep->userName);
 } }
  
   
 // //
 // SubscriptionInstanceContainer // SubscriptionInstanceContainer
 // //
Line 320 
Line 310 
  
 SubscriptionInstanceContainer::SubscriptionInstanceContainer SubscriptionInstanceContainer::SubscriptionInstanceContainer
     (const SubscriptionInstanceContainer & container)     (const SubscriptionInstanceContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionInstanceContainerRep();     _rep = new SubscriptionInstanceContainerRep();
     _rep->subscriptionInstance = container._rep->subscriptionInstance;     _rep->subscriptionInstance = container._rep->subscriptionInstance;
Line 401 
Line 394 
  
 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
     (const SubscriptionInstanceNamesContainer & container)     (const SubscriptionInstanceNamesContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionInstanceNamesContainerRep();     _rep = new SubscriptionInstanceNamesContainerRep();
     _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;     _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
Line 455 
Line 451 
     return(_rep->subscriptionInstanceNames);     return(_rep->subscriptionInstanceNames);
 } }
  
   
 // //
 // SubscriptionFilterConditionContainer // SubscriptionFilterConditionContainer
 // //
Line 487 
Line 484 
  
 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
     (const SubscriptionFilterConditionContainer & container)     (const SubscriptionFilterConditionContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionFilterConditionContainerRep();     _rep = new SubscriptionFilterConditionContainerRep();
     _rep->filterCondition = container._rep->filterCondition;     _rep->filterCondition = container._rep->filterCondition;
Line 550 
Line 550 
 } }
  
  
   //
   // SubscriptionFilterQueryContainer
   //
   
   class SubscriptionFilterQueryContainerRep
   {
   public:
     String filterQuery;
     String queryLanguage;
     CIMNamespaceName sourceNameSpace;
   };
   
   const String SubscriptionFilterQueryContainer::NAME =
       "SubscriptionFilterQueryContainer";
   
   SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer
       (const OperationContext::Container & container)
   {
       const SubscriptionFilterQueryContainer * p =
           dynamic_cast<const SubscriptionFilterQueryContainer *>(&container);
   
       if(p == 0)
       {
           throw DynamicCastFailedException();
       }
   
       _rep = new SubscriptionFilterQueryContainerRep();
       _rep->filterQuery = p->_rep->filterQuery;
       _rep->queryLanguage = p->_rep->queryLanguage;
       _rep->sourceNameSpace = p->_rep->sourceNameSpace;
   }
   
   SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer
       (const SubscriptionFilterQueryContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
   {
       _rep = new SubscriptionFilterQueryContainerRep();
       _rep->filterQuery = container._rep->filterQuery;
       _rep->queryLanguage = container._rep->queryLanguage;
       _rep->sourceNameSpace = container._rep->sourceNameSpace;
   }
   
   SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
       const String & filterQuery,
       const String & queryLanguage,
       const CIMNamespaceName & sourceNameSpace)
   {
       _rep = new SubscriptionFilterQueryContainerRep();
       _rep->filterQuery = filterQuery;
       _rep->queryLanguage = queryLanguage;
       _rep->sourceNameSpace = sourceNameSpace;
   }
   
   SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer
       (void)
   {
       delete _rep;
   }
   SubscriptionFilterQueryContainer &
       SubscriptionFilterQueryContainer::operator=(
       const SubscriptionFilterQueryContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->filterQuery = container._rep->filterQuery;
       _rep->queryLanguage = container._rep->queryLanguage;
       _rep->sourceNameSpace = container._rep->sourceNameSpace;
   
       return (*this);
   }
   
   String SubscriptionFilterQueryContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * SubscriptionFilterQueryContainer::clone(void) const
   {
       return(new SubscriptionFilterQueryContainer(_rep->filterQuery,
                                                   _rep->queryLanguage,
                                                   _rep->sourceNameSpace));
   }
   
   void SubscriptionFilterQueryContainer::destroy(void)
   {
       delete this;
   }
   
   String SubscriptionFilterQueryContainer::getFilterQuery(void) const
   {
       return(_rep->filterQuery);
   }
   
   String SubscriptionFilterQueryContainer::getQueryLanguage(void) const
   {
       return(_rep->queryLanguage);
   }
   
   CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace(void) const
   {
       return(_rep->sourceNameSpace);
   }
   
   
   //
   // TimeoutContainer
   //
   
 const String TimeoutContainer::NAME = "TimeoutContainer"; const String TimeoutContainer::NAME = "TimeoutContainer";
  
 TimeoutContainer::TimeoutContainer(const OperationContext::Container & container) TimeoutContainer::TimeoutContainer(const OperationContext::Container & container)
Line 588 
Line 701 
 } }
  
  
   //
   // AcceptLanguageListContainer
   //
   
   class AcceptLanguageListContainerRep
   {
   public:
       AcceptLanguageList languages;
   };
   
   const String AcceptLanguageListContainer::NAME =
       "AcceptLanguageListContainer";
   
   AcceptLanguageListContainer::AcceptLanguageListContainer
       (const OperationContext::Container & container)
   {
       const AcceptLanguageListContainer * p =
           dynamic_cast<const AcceptLanguageListContainer *>(&container);
   
       if(p == 0)
       {
           throw DynamicCastFailedException();
       }
   
       _rep = new AcceptLanguageListContainerRep();
       _rep->languages = p->_rep->languages;
   }
   
   AcceptLanguageListContainer::AcceptLanguageListContainer
       (const AcceptLanguageListContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
   {
       _rep = new AcceptLanguageListContainerRep();
       _rep->languages = container._rep->languages;
   }
   
   AcceptLanguageListContainer::AcceptLanguageListContainer
       (const AcceptLanguageList & languages)
   {
       _rep = new AcceptLanguageListContainerRep();
       _rep->languages = languages;
   }
   
   AcceptLanguageListContainer::~AcceptLanguageListContainer(void)
   {
       delete _rep;
   }
   
   AcceptLanguageListContainer & AcceptLanguageListContainer::operator=(
       const AcceptLanguageListContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->languages = container._rep->languages;
   
       return (*this);
   }
   
   String AcceptLanguageListContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * AcceptLanguageListContainer::clone(void) const
   {
       return(new AcceptLanguageListContainer(_rep->languages));
   }
   
   void AcceptLanguageListContainer::destroy(void)
   {
       delete this;
   }
   
   AcceptLanguageList AcceptLanguageListContainer::getLanguages(void) const
   {
       return(_rep->languages);
   }
   
   
   //
   // ContentLanguageListContainer
   //
   
   class ContentLanguageListContainerRep
   {
   public:
       ContentLanguageList languages;
   };
   
   const String ContentLanguageListContainer::NAME =
       "ContentLanguageListContainer";
   
   ContentLanguageListContainer::ContentLanguageListContainer
       (const OperationContext::Container & container)
   {
       const ContentLanguageListContainer * p =
           dynamic_cast<const ContentLanguageListContainer *>(&container);
   
       if(p == 0)
       {
           throw DynamicCastFailedException();
       }
   
       _rep = new ContentLanguageListContainerRep();
       _rep->languages = p->_rep->languages;
   }
  
   ContentLanguageListContainer::ContentLanguageListContainer
       (const ContentLanguageListContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
   {
       _rep = new ContentLanguageListContainerRep();
       _rep->languages = container._rep->languages;
   }
   
   ContentLanguageListContainer::ContentLanguageListContainer
       (const ContentLanguageList & languages)
   {
       _rep = new ContentLanguageListContainerRep();
       _rep->languages = languages;
   }
   
   ContentLanguageListContainer::~ContentLanguageListContainer(void)
   {
       delete _rep;
   }
   
   ContentLanguageListContainer & ContentLanguageListContainer::operator=(
       const ContentLanguageListContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->languages = container._rep->languages;
   
       return (*this);
   }
  
   String ContentLanguageListContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * ContentLanguageListContainer::clone(void) const
   {
       return(new ContentLanguageListContainer(_rep->languages));
   }
   
   void ContentLanguageListContainer::destroy(void)
   {
       delete this;
   }
   
   ContentLanguageList ContentLanguageListContainer::getLanguages(void) const
   {
       return(_rep->languages);
   }
   
   
   
   //
   // SnmpTrapOidContainer
   //
   
   class SnmpTrapOidContainerRep
   {
   public:
       String snmpTrapOid;
   };
   
   const String SnmpTrapOidContainer::NAME =
       "SnmpTrapOidContainer";
   
   SnmpTrapOidContainer::SnmpTrapOidContainer
       (const OperationContext::Container & container)
   {
       const SnmpTrapOidContainer * p =
           dynamic_cast<const SnmpTrapOidContainer *>(&container);
   
       if(p == 0)
       {
           throw DynamicCastFailedException();
       }
   
       _rep = new SnmpTrapOidContainerRep();
       _rep->snmpTrapOid = p->_rep->snmpTrapOid;
   }
   
   SnmpTrapOidContainer::SnmpTrapOidContainer
       (const SnmpTrapOidContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
        : OperationContext::Container()
   #endif
   {
       _rep = new SnmpTrapOidContainerRep();
       _rep->snmpTrapOid = container._rep->snmpTrapOid;
   }
   
   SnmpTrapOidContainer::SnmpTrapOidContainer
       (const String & snmpTrapOid)
   {
       _rep = new SnmpTrapOidContainerRep();
       _rep->snmpTrapOid = snmpTrapOid;
   }
   
   SnmpTrapOidContainer::~SnmpTrapOidContainer(void)
   {
       delete _rep;
   }
   
   SnmpTrapOidContainer & SnmpTrapOidContainer::operator=(
       const SnmpTrapOidContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->snmpTrapOid = container._rep->snmpTrapOid;
   
       return (*this);
   }
   
   String SnmpTrapOidContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * SnmpTrapOidContainer::clone(void) const
   {
       return(new SnmpTrapOidContainer(_rep->snmpTrapOid));
   }
   
   void SnmpTrapOidContainer::destroy(void)
   {
       delete this;
   }
   
   String SnmpTrapOidContainer::getSnmpTrapOid(void) const
   {
       return(_rep->snmpTrapOid);
   }
   
   //
   // SSLCertificateChainContainerRep
   //
   
   class SSLCertificateChainContainerRep
   {
   public:
       Array<SSLCertificateInfo> userCert;
   };
   
   //
   // SSLCertificateChainContainer
   //
   
   const String SSLCertificateChainContainer::NAME =
       "SSLCertificateChainContainer";
   
   SSLCertificateChainContainer::SSLCertificateChainContainer(
       const OperationContext::Container & container)
   {
       const SSLCertificateChainContainer *p =
           dynamic_cast<const SSLCertificateChainContainer *>(&container);
   
       if(p == 0)
       {
           throw DynamicCastFailedException();
       }
       _rep = new SSLCertificateChainContainerRep();
       _rep->userCert = p->_rep->userCert;
   }
   
   SSLCertificateChainContainer::SSLCertificateChainContainer(
       const SSLCertificateChainContainer & container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
        : OperationContext::Container()
   #endif
   {
       _rep = new SSLCertificateChainContainerRep();
       _rep->userCert = container._rep->userCert;
   }
   
   SSLCertificateChainContainer::SSLCertificateChainContainer(
       const Array<SSLCertificateInfo>& userCert)
   {
       _rep = new SSLCertificateChainContainerRep();
       _rep->userCert = userCert;
   }
   
   SSLCertificateChainContainer::~SSLCertificateChainContainer(void)
   {
       delete _rep;
   }
   
   SSLCertificateChainContainer & SSLCertificateChainContainer::operator=(
       const SSLCertificateChainContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
       _rep->userCert = container._rep->userCert;
       return (*this);
   }
   
   String SSLCertificateChainContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * SSLCertificateChainContainer::clone(void) const
   {
       return(new SSLCertificateChainContainer(_rep->userCert));
   }
   
   void SSLCertificateChainContainer::destroy(void)
   {
       delete this;
   }
   
   Array<SSLCertificateInfo> SSLCertificateChainContainer::getUserCert(void) const
   {
       return(_rep->userCert);
   }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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