(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.6 and 1.17

version 1.6, 2002/05/22 21:35:47 version 1.17, 2003/04/16 00:17:14
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // 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
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 22 
Line 23 
 // //
 // Author: Chip Vincent (cvincent@us.ibm.com) // Author: Chip Vincent (cvincent@us.ibm.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "OperationContext.h" #include "OperationContext.h"
   #include "ArrayInternal.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 // //
 // OperationContext // OperationContext
 // //
   
   class OperationContextRep
   {
   public:
       Array<OperationContext::Container *> containers;
   };
   
 OperationContext::OperationContext(void) OperationContext::OperationContext(void)
 { {
       _rep = new OperationContextRep;
 } }
  
 OperationContext::OperationContext(const OperationContext & context) OperationContext::OperationContext(const OperationContext & context)
 { {
       _rep = new OperationContextRep;
     *this = context;     *this = context;
 } }
  
 OperationContext::~OperationContext(void) OperationContext::~OperationContext(void)
 { {
     clear();     clear();
       delete _rep;
 } }
  
 OperationContext & OperationContext::operator=(const OperationContext & context) OperationContext & OperationContext::operator=(const OperationContext & context)
Line 56 
Line 70 
  
     clear();     clear();
  
     for(Uint32 i = 0, n = context._containers.size(); i < n; i++)      for(Uint32 i = 0, n = context._rep->containers.size(); i < n; i++)
     {     {
         _containers.append(context._containers[i]->clone());          _rep->containers.append(context._rep->containers[i]->clone());
     }     }
  
     return(*this);     return(*this);
Line 66 
Line 80 
  
 void OperationContext::clear(void) void OperationContext::clear(void)
 { {
     for(Uint32 i = 0, n = _containers.size(); i < n; i++)      for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
     {     {
         delete _containers[i];          _rep->containers[i]->destroy();
       }
   
       _rep->containers.clear();
   }
   
   const OperationContext::Container & OperationContext::get(
       const String& containerName) const
   {
       for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
       {
           if(containerName == _rep->containers[i]->getName())
           {
               Container * p = _rep->containers[i];
   
               return(*p);
           }
     }     }
  
     _containers.clear();      throw Exception("object not found");
 } }
  
   #ifndef PEGASUS_REMOVE_DEPRECATED
 const OperationContext::Container & OperationContext::get(const Uint32 key) const const OperationContext::Container & OperationContext::get(const Uint32 key) const
 { {
     for(Uint32 i = 0, n = _containers.size(); i < n; i++)      for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
     {     {
         if(key == _containers[i]->getKey())          if(key == _rep->containers[i]->getKey())
         {         {
             Container * p = _containers[i];              Container * p = _rep->containers[i];
  
             return(*p);             return(*p);
         }         }
Line 88 
Line 119 
  
     throw Exception("object not found");     throw Exception("object not found");
 } }
   #endif
  
 void OperationContext::set(const OperationContext::Container & container) void OperationContext::set(const OperationContext::Container & container)
 { {
     for(Uint32 i = 0, n = _containers.size(); i < n; i++)      for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
     {     {
         if(container.getKey() == _containers[i]->getKey())          if(container.getName() == _rep->containers[i]->getName())
         {         {
             // delete previous container             // delete previous container
             _containers.remove(i);              _rep->containers[i]->destroy();
               _rep->containers.remove(i);
  
             // append current container             // append current container
             _containers.append(container.clone());              _rep->containers.append(container.clone());
  
             return;             return;
         }         }
Line 110 
Line 143 
  
 void OperationContext::insert(const OperationContext::Container & container) void OperationContext::insert(const OperationContext::Container & container)
 { {
     for(Uint32 i = 0, n = _containers.size(); i < n; i++)      for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
     {     {
         if(container.getKey() == _containers[i]->getKey())          if(container.getName() == _rep->containers[i]->getName())
         {         {
             throw Exception("object already exists.");             throw Exception("object already exists.");
         }         }
     }     }
  
     _containers.append(container.clone());      _rep->containers.append(container.clone());
   }
   
   void OperationContext::remove(const String& containerName)
   {
       for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
       {
           if(containerName == _rep->containers[i]->getName())
           {
               _rep->containers[i]->destroy();
               _rep->containers.remove(i);
   
               return;
           }
       }
   
       throw Exception("object not found");
 } }
  
   #ifndef PEGASUS_REMOVE_DEPRECATED
 void OperationContext::remove(const Uint32 key) void OperationContext::remove(const Uint32 key)
 { {
     for(Uint32 i = 0, n = _containers.size(); i < n; i++)      for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
     {     {
         if(key == _containers[i]->getKey())          if(key == _rep->containers[i]->getKey())
         {         {
             _containers.remove(i);              delete _rep->containers[i];
               _rep->containers.remove(i);
  
             return;             return;
         }         }
Line 135 
Line 186 
  
     throw Exception("object not found");     throw Exception("object not found");
 } }
   #endif
  
 // //
 // OperationContext::Container // OperationContext::Container
 // //
   
   #ifndef PEGASUS_REMOVE_DEPRECATED
 OperationContext::Container::Container(const Uint32 key) : _key(key) OperationContext::Container::Container(const Uint32 key) : _key(key)
 { {
 } }
   #endif
  
 OperationContext::Container::~Container(void) OperationContext::Container::~Container(void)
 { {
 } }
  
 OperationContext::Container * OperationContext::Container::clone(void) const  #ifndef PEGASUS_REMOVE_DEPRECATED
   const Uint32 & OperationContext::Container::getKey(void) const
 { {
     return(new Container(*this));      return(_key);
 } }
   #endif
  
 // //
 // IdentitiyContainer  // IdentityContainer
 // //
   
   class IdentityContainerRep
   {
   public:
       String userName;
   };
   
   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);
  
     if(p == 0)     if(p == 0)
     {     {
         throw DynamicCastFailed();          throw DynamicCastFailedException();
     }     }
  
     *this = *p;      _rep = new IdentityContainerRep();
       _rep->userName = p->_rep->userName;
   }
   
   IdentityContainer::IdentityContainer(const IdentityContainer & container)
   {
       _rep = new IdentityContainerRep();
       _rep->userName = container._rep->userName;
 } }
  
 IdentityContainer::IdentityContainer(const String & userName) IdentityContainer::IdentityContainer(const String & userName)
     : OperationContext::Container(CONTEXT_IDENTITY), _userName(userName)  #ifndef PEGASUS_REMOVE_DEPRECATED
       : OperationContext::Container(CONTEXT_IDENTITY)
   #endif
 { {
       _rep = new IdentityContainerRep();
       _rep->userName = userName;
   }
   
   IdentityContainer::~IdentityContainer(void)
   {
       delete _rep;
   }
   
   IdentityContainer & IdentityContainer::operator=(
       const IdentityContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->userName = container._rep->userName;
   
       return (*this);
   }
   
   String IdentityContainer::getName(void) const
   {
       return(NAME);
 } }
  
 OperationContext::Container * IdentityContainer::clone(void) const OperationContext::Container * IdentityContainer::clone(void) const
 { {
     return(new IdentityContainer(*this));      return(new IdentityContainer(_rep->userName));
   }
   
   void IdentityContainer::destroy(void)
   {
       delete this;
 } }
  
 String IdentityContainer::getUserName(void) const String IdentityContainer::getUserName(void) const
 { {
     return(_userName);      return(_rep->userName);
 } }
  
 // //
 // LocaleContainer  // SubscriptionInstanceContainer
 // //
 LocaleContainer::LocaleContainer(const OperationContext::Container & container)  
   class SubscriptionInstanceContainerRep
   {
   public:
       CIMInstance subscriptionInstance;
   };
   
   const String SubscriptionInstanceContainer::NAME =
       "SubscriptionInstanceContainer";
   
   SubscriptionInstanceContainer::SubscriptionInstanceContainer
       (const OperationContext::Container & container)
 { {
     const LocaleContainer * p = dynamic_cast<const LocaleContainer *>(&container);      const SubscriptionInstanceContainer * p =
           dynamic_cast<const SubscriptionInstanceContainer *>(&container);
  
     if(p == 0)     if(p == 0)
     {     {
         throw DynamicCastFailed();          throw DynamicCastFailedException();
     }     }
  
     *this = *p;      _rep = new SubscriptionInstanceContainerRep();
       _rep->subscriptionInstance = p->_rep->subscriptionInstance;
 } }
  
 LocaleContainer::LocaleContainer(const String & languageId)  SubscriptionInstanceContainer::SubscriptionInstanceContainer
     : OperationContext::Container(CONTEXT_LOCALE), _languageId(languageId)      (const SubscriptionInstanceContainer & container)
 { {
       _rep = new SubscriptionInstanceContainerRep();
       _rep->subscriptionInstance = container._rep->subscriptionInstance;
 } }
  
 OperationContext::Container * LocaleContainer::clone(void) const  SubscriptionInstanceContainer::SubscriptionInstanceContainer
       (const CIMInstance & subscriptionInstance)
 { {
     return(new LocaleContainer(*this));      _rep = new SubscriptionInstanceContainerRep();
       _rep->subscriptionInstance = subscriptionInstance;
 } }
  
 String LocaleContainer::getLanguageId(void) const  SubscriptionInstanceContainer::~SubscriptionInstanceContainer(void)
 { {
     return(_languageId);      delete _rep;
 } }
  
   SubscriptionInstanceContainer & SubscriptionInstanceContainer::operator=(
       const SubscriptionInstanceContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->subscriptionInstance = container._rep->subscriptionInstance;
   
       return (*this);
   }
   
   String SubscriptionInstanceContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * SubscriptionInstanceContainer::clone(void) const
   {
       return(new SubscriptionInstanceContainer(_rep->subscriptionInstance));
   }
   
   void SubscriptionInstanceContainer::destroy(void)
   {
       delete this;
   }
   
   CIMInstance SubscriptionInstanceContainer::getInstance(void) const
   {
       return(_rep->subscriptionInstance);
   }
   
   
 // //
 // ProviderIdContainer  // SubscriptionInstanceNamesContainer
 // //
 ProviderIdContainer::ProviderIdContainer(const OperationContext::Container & container)  
   class SubscriptionInstanceNamesContainerRep
 { {
     const ProviderIdContainer * p = dynamic_cast<const ProviderIdContainer *>(&container);  public:
       Array<CIMObjectPath> subscriptionInstanceNames;
   };
   
   const String SubscriptionInstanceNamesContainer::NAME =
       "SubscriptionInstanceNamesContainer";
   
   SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
       (const OperationContext::Container & container)
   {
       const SubscriptionInstanceNamesContainer * p =
           dynamic_cast<const SubscriptionInstanceNamesContainer *>(&container);
  
     if(p == 0)     if(p == 0)
     {     {
         throw DynamicCastFailed();          throw DynamicCastFailedException();
     }     }
  
     *this = *p;      _rep = new SubscriptionInstanceNamesContainerRep();
       _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;
 } }
  
 ProviderIdContainer::ProviderIdContainer(const CIMInstance & module, const CIMInstance & provider)  SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
     : OperationContext::Container(CONTEXT_PROVIDERID), _module(module), _provider(provider)      (const SubscriptionInstanceNamesContainer & container)
 { {
       _rep = new SubscriptionInstanceNamesContainerRep();
       _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
 } }
  
 OperationContext::Container * ProviderIdContainer::clone(void) const  SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
       (const Array<CIMObjectPath> & subscriptionInstanceNames)
 { {
     return(new ProviderIdContainer(*this));      _rep = new SubscriptionInstanceNamesContainerRep();
       _rep->subscriptionInstanceNames = subscriptionInstanceNames;
 } }
  
 CIMInstance ProviderIdContainer::getModule(void) const  SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer(void)
 { {
     return(_module);      delete _rep;
 } }
  
 CIMInstance ProviderIdContainer::getProvider(void) const  SubscriptionInstanceNamesContainer &
       SubscriptionInstanceNamesContainer::operator=(
       const SubscriptionInstanceNamesContainer & container)
   {
       if (this == &container)
 { {
     return(_provider);          return (*this);
       }
   
       _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
   
       return (*this);
 } }
  
   String SubscriptionInstanceNamesContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container *
       SubscriptionInstanceNamesContainer::clone(void) const
   {
       return(new SubscriptionInstanceNamesContainer
           (_rep->subscriptionInstanceNames));
   }
   
   void SubscriptionInstanceNamesContainer::destroy(void)
   {
       delete this;
   }
   
   Array<CIMObjectPath>
       SubscriptionInstanceNamesContainer::getInstanceNames(void) const
   {
       return(_rep->subscriptionInstanceNames);
   }
   
   //
   // SubscriptionFilterConditionContainer
   //
   
   class SubscriptionFilterConditionContainerRep
   {
   public:
       String filterCondition;
       String queryLanguage;
   };
   
   const String SubscriptionFilterConditionContainer::NAME =
       "SubscriptionFilterConditionContainer";
   
   SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
       (const OperationContext::Container & container)
   {
       const SubscriptionFilterConditionContainer * p =
           dynamic_cast<const SubscriptionFilterConditionContainer *>(&container);
   
       if(p == 0)
       {
           throw DynamicCastFailedException();
       }
   
       _rep = new SubscriptionFilterConditionContainerRep();
       _rep->filterCondition = p->_rep->filterCondition;
       _rep->queryLanguage = p->_rep->queryLanguage;
   }
   
   SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
       (const SubscriptionFilterConditionContainer & container)
   {
       _rep = new SubscriptionFilterConditionContainerRep();
       _rep->filterCondition = container._rep->filterCondition;
       _rep->queryLanguage = container._rep->queryLanguage;
   }
   
   SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
       const String & filterCondition,
       const String & queryLanguage)
   {
       _rep = new SubscriptionFilterConditionContainerRep();
       _rep->filterCondition = filterCondition;
       _rep->queryLanguage = queryLanguage;
   }
   
   SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer
       (void)
   {
       delete _rep;
   }
   
   SubscriptionFilterConditionContainer &
       SubscriptionFilterConditionContainer::operator=(
       const SubscriptionFilterConditionContainer & container)
   {
       if (this == &container)
       {
           return (*this);
       }
   
       _rep->filterCondition = container._rep->filterCondition;
       _rep->queryLanguage = container._rep->queryLanguage;
   
       return (*this);
   }
   
   String SubscriptionFilterConditionContainer::getName(void) const
   {
       return(NAME);
   }
   
   OperationContext::Container * SubscriptionFilterConditionContainer::clone(void) const
   {
       return(new SubscriptionFilterConditionContainer(_rep->filterCondition,
           _rep->queryLanguage));
   }
   
   void SubscriptionFilterConditionContainer::destroy(void)
   {
       delete this;
   }
   
   String SubscriptionFilterConditionContainer::getFilterCondition(void) const
   {
       return(_rep->filterCondition);
   }
   
   String SubscriptionFilterConditionContainer::getQueryLanguage(void) const
   {
       return(_rep->queryLanguage);
   }
   
   
   const String TimeoutContainer::NAME = "TimeoutContainer";
   
   TimeoutContainer::TimeoutContainer(const OperationContext::Container & container)
   {
      const TimeoutContainer * p = dynamic_cast<const TimeoutContainer *>(&container);
      if(p == 0)
      {
         throw DynamicCastFailedException();
      }
      _value = p->_value;
   }
   
   TimeoutContainer::TimeoutContainer(Uint32 timeout)
   {
      _value = timeout;
   }
   
   String TimeoutContainer::getName(void) const
   {
      return (NAME);
   }
   
   OperationContext::Container * TimeoutContainer::clone(void) const
   {
      return (new TimeoutContainer(_value));
   }
   
   void TimeoutContainer::destroy(void)
   {
      delete this;
   }
   
   Uint32 TimeoutContainer::getTimeOut(void) const
   {
      return _value;
   }
   
   
   
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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