(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.44

version 1.17, 2003/04/16 00:17:14 version 1.44, 2008/12/02 09:00:50
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Licensed to The Open Group (TOG) under one or more contributor license
 // The Open Group, Tivoli Systems  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
   //
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  //////////////////////////////////////////////////////////////////////////
 // of this software and associated documentation files (the "Software"), to  
 // deal in the Software without restriction, including without limitation the  
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  
 // sell copies of the Software, and to permit persons to whom the Software is  
 // furnished to do so, subject to the following conditions:  
 //  
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 //  
 //==============================================================================  
 //  
 // Author: Chip Vincent (cvincent@us.ibm.com)  
 //  
 // 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" #include "ArrayInternal.h"
   #include <Pegasus/Common/MessageLoader.h>
   
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
       defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU) || \
       defined(PEGASUS_PLATFORM_DARWIN_IX86_GNU)
   # define PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
   #endif
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 44 
Line 51 
     Array<OperationContext::Container *> containers;     Array<OperationContext::Container *> containers;
 }; };
  
 OperationContext::OperationContext(void)  OperationContext::OperationContext()
 { {
     _rep = new OperationContextRep;     _rep = new OperationContextRep;
 } }
Line 55 
Line 62 
     *this = context;     *this = context;
 } }
  
 OperationContext::~OperationContext(void)  OperationContext::~OperationContext()
 { {
     clear();     clear();
     delete _rep;     delete _rep;
Line 65 
Line 72 
 { {
     if(this == &context)     if(this == &context)
     {     {
         return(*this);          return *this;
     }     }
  
     clear();     clear();
Line 75 
Line 82 
         _rep->containers.append(context._rep->containers[i]->clone());         _rep->containers.append(context._rep->containers[i]->clone());
     }     }
  
     return(*this);      return *this;
 } }
  
 void OperationContext::clear(void)  void OperationContext::clear()
 { {
     for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)     for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
     {     {
Line 91 
Line 98 
 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]);
  
     throw Exception("object not found");      static Exception _exception(MessageLoaderParms(
           "Common.OperationContext.OBJECT_NOT_FOUND", "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 143 
         }         }
     }     }
  
     throw Exception("object not found");      MessageLoaderParms parms(
           "Common.OperationContext.OBJECT_NOT_FOUND",
           "object not found");
       throw Exception(parms);
 } }
  
 void OperationContext::insert(const OperationContext::Container & container) void OperationContext::insert(const OperationContext::Container & container)
Line 147 
Line 155 
     {     {
         if(container.getName() == _rep->containers[i]->getName())         if(container.getName() == _rep->containers[i]->getName())
         {         {
             throw Exception("object already exists.");              MessageLoaderParms parms(
                   "Common.OperationContext.OBJECT_ALREADY_EXISTS",
                   "object already exists.");
               throw Exception(parms);
         }         }
     }     }
  
Line 167 
Line 178 
         }         }
     }     }
  
     throw Exception("object not found");      MessageLoaderParms parms(
           "Common.OperationContext.OBJECT_NOT_FOUND",
           "object not found");
       throw Exception(parms);
 } }
  
 #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()
 OperationContext::Container::Container(const Uint32 key) : _key(key)  
 { {
 } }
 #endif  
  
 OperationContext::Container::~Container(void)  
 {  
 }  
   
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 const Uint32 & OperationContext::Container::getKey(void) const  
 {  
     return(_key);  
 }  
 #endif  
  
 // //
 // IdentityContainer // IdentityContainer
Line 221 
Line 206 
  
 const String IdentityContainer::NAME = "IdentityContainer"; const String IdentityContainer::NAME = "IdentityContainer";
  
 IdentityContainer::IdentityContainer(const OperationContext::Container & container)  IdentityContainer::IdentityContainer(
 #ifndef PEGASUS_REMOVE_DEPRECATED      const OperationContext::Container& container)
     : 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)
     {     {
Line 238 
Line 222 
 } }
  
 IdentityContainer::IdentityContainer(const IdentityContainer & container) IdentityContainer::IdentityContainer(const IdentityContainer & container)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : 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;
 } }
  
 IdentityContainer::~IdentityContainer(void)  IdentityContainer::~IdentityContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 262 
Line 246 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->userName = container._rep->userName;     _rep->userName = container._rep->userName;
  
     return (*this);      return *this;
 } }
  
 String IdentityContainer::getName(void) const  String IdentityContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * IdentityContainer::clone(void) const  OperationContext::Container* IdentityContainer::clone() const
 { {
     return(new IdentityContainer(_rep->userName));      return new IdentityContainer(_rep->userName);
 } }
  
 void IdentityContainer::destroy(void)  void IdentityContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 String IdentityContainer::getUserName(void) const  String IdentityContainer::getUserName() const
 { {
     return(_rep->userName);      return _rep->userName;
 } }
  
   
 // //
 // SubscriptionInstanceContainer // SubscriptionInstanceContainer
 // //
Line 303 
Line 288 
 const String SubscriptionInstanceContainer::NAME = const String SubscriptionInstanceContainer::NAME =
     "SubscriptionInstanceContainer";     "SubscriptionInstanceContainer";
  
 SubscriptionInstanceContainer::SubscriptionInstanceContainer  SubscriptionInstanceContainer::SubscriptionInstanceContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const SubscriptionInstanceContainer * p =     const SubscriptionInstanceContainer * p =
         dynamic_cast<const SubscriptionInstanceContainer *>(&container);         dynamic_cast<const SubscriptionInstanceContainer *>(&container);
Line 318 
Line 303 
     _rep->subscriptionInstance = p->_rep->subscriptionInstance;     _rep->subscriptionInstance = p->_rep->subscriptionInstance;
 } }
  
 SubscriptionInstanceContainer::SubscriptionInstanceContainer  SubscriptionInstanceContainer::SubscriptionInstanceContainer(
     (const SubscriptionInstanceContainer & container)      const SubscriptionInstanceContainer& container)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionInstanceContainerRep();     _rep = new SubscriptionInstanceContainerRep();
     _rep->subscriptionInstance = container._rep->subscriptionInstance;     _rep->subscriptionInstance = container._rep->subscriptionInstance;
 } }
  
 SubscriptionInstanceContainer::SubscriptionInstanceContainer  SubscriptionInstanceContainer::SubscriptionInstanceContainer(
     (const CIMInstance & subscriptionInstance)      const CIMInstance& subscriptionInstance)
 { {
     _rep = new SubscriptionInstanceContainerRep();     _rep = new SubscriptionInstanceContainerRep();
     _rep->subscriptionInstance = subscriptionInstance;     _rep->subscriptionInstance = subscriptionInstance;
 } }
  
 SubscriptionInstanceContainer::~SubscriptionInstanceContainer(void)  SubscriptionInstanceContainer::~SubscriptionInstanceContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 342 
Line 330 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->subscriptionInstance = container._rep->subscriptionInstance;     _rep->subscriptionInstance = container._rep->subscriptionInstance;
  
     return (*this);      return *this;
 } }
  
 String SubscriptionInstanceContainer::getName(void) const  String SubscriptionInstanceContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * SubscriptionInstanceContainer::clone(void) const  OperationContext::Container* SubscriptionInstanceContainer::clone() const
 { {
     return(new SubscriptionInstanceContainer(_rep->subscriptionInstance));      return new SubscriptionInstanceContainer(_rep->subscriptionInstance);
 } }
  
 void SubscriptionInstanceContainer::destroy(void)  void SubscriptionInstanceContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 CIMInstance SubscriptionInstanceContainer::getInstance(void) const  CIMInstance SubscriptionInstanceContainer::getInstance() const
 { {
     return(_rep->subscriptionInstance);      return _rep->subscriptionInstance;
 } }
  
  
Line 384 
Line 372 
 const String SubscriptionInstanceNamesContainer::NAME = const String SubscriptionInstanceNamesContainer::NAME =
     "SubscriptionInstanceNamesContainer";     "SubscriptionInstanceNamesContainer";
  
 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer  SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const SubscriptionInstanceNamesContainer * p =     const SubscriptionInstanceNamesContainer * p =
         dynamic_cast<const SubscriptionInstanceNamesContainer *>(&container);         dynamic_cast<const SubscriptionInstanceNamesContainer *>(&container);
Line 399 
Line 387 
     _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;     _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;
 } }
  
 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer  SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer(
     (const SubscriptionInstanceNamesContainer & container)      const SubscriptionInstanceNamesContainer& container)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionInstanceNamesContainerRep();     _rep = new SubscriptionInstanceNamesContainerRep();
     _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;     _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
 } }
  
 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer  SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer(
     (const Array<CIMObjectPath> & subscriptionInstanceNames)      const Array<CIMObjectPath>& subscriptionInstanceNames)
 { {
     _rep = new SubscriptionInstanceNamesContainerRep();     _rep = new SubscriptionInstanceNamesContainerRep();
     _rep->subscriptionInstanceNames = subscriptionInstanceNames;     _rep->subscriptionInstanceNames = subscriptionInstanceNames;
 } }
  
 SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer(void)  SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 424 
Line 415 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;     _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
  
     return (*this);      return *this;
 } }
  
 String SubscriptionInstanceNamesContainer::getName(void) const  String SubscriptionInstanceNamesContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * OperationContext::Container *
     SubscriptionInstanceNamesContainer::clone(void) const      SubscriptionInstanceNamesContainer::clone() const
 { {
     return(new SubscriptionInstanceNamesContainer      return new SubscriptionInstanceNamesContainer(
         (_rep->subscriptionInstanceNames));          _rep->subscriptionInstanceNames);
 } }
  
 void SubscriptionInstanceNamesContainer::destroy(void)  void SubscriptionInstanceNamesContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 Array<CIMObjectPath> Array<CIMObjectPath>
     SubscriptionInstanceNamesContainer::getInstanceNames(void) const      SubscriptionInstanceNamesContainer::getInstanceNames() const
 { {
     return(_rep->subscriptionInstanceNames);      return _rep->subscriptionInstanceNames;
 } }
  
   
 // //
 // SubscriptionFilterConditionContainer // SubscriptionFilterConditionContainer
 // //
Line 469 
Line 461 
 const String SubscriptionFilterConditionContainer::NAME = const String SubscriptionFilterConditionContainer::NAME =
     "SubscriptionFilterConditionContainer";     "SubscriptionFilterConditionContainer";
  
 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer  SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const SubscriptionFilterConditionContainer * p =     const SubscriptionFilterConditionContainer * p =
         dynamic_cast<const SubscriptionFilterConditionContainer *>(&container);         dynamic_cast<const SubscriptionFilterConditionContainer *>(&container);
Line 485 
Line 477 
     _rep->queryLanguage = p->_rep->queryLanguage;     _rep->queryLanguage = p->_rep->queryLanguage;
 } }
  
 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer  SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
     (const SubscriptionFilterConditionContainer & container)      const SubscriptionFilterConditionContainer& container)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionFilterConditionContainerRep();     _rep = new SubscriptionFilterConditionContainerRep();
     _rep->filterCondition = container._rep->filterCondition;     _rep->filterCondition = container._rep->filterCondition;
Line 502 
Line 497 
     _rep->queryLanguage = queryLanguage;     _rep->queryLanguage = queryLanguage;
 } }
  
 SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer  SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer()
     (void)  
 { {
     delete _rep;     delete _rep;
 } }
Line 514 
Line 508 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->filterCondition = container._rep->filterCondition;     _rep->filterCondition = container._rep->filterCondition;
     _rep->queryLanguage = container._rep->queryLanguage;     _rep->queryLanguage = container._rep->queryLanguage;
  
     return (*this);      return *this;
   }
   
   String SubscriptionFilterConditionContainer::getName() const
   {
       return NAME;
   }
   
   OperationContext::Container* SubscriptionFilterConditionContainer::clone() const
   {
       return new SubscriptionFilterConditionContainer(
           _rep->filterCondition, _rep->queryLanguage);
   }
   
   void SubscriptionFilterConditionContainer::destroy()
   {
       delete this;
   }
   
   String SubscriptionFilterConditionContainer::getFilterCondition() const
   {
       return _rep->filterCondition;
   }
   
   String SubscriptionFilterConditionContainer::getQueryLanguage() const
   {
       return _rep->queryLanguage;
   }
   
   
   //
   // 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)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : 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;
 } }
  
 String SubscriptionFilterConditionContainer::getName(void) const  SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer()
 { {
     return(NAME);      delete _rep;
 } }
  
 OperationContext::Container * SubscriptionFilterConditionContainer::clone(void) const  SubscriptionFilterQueryContainer&
       SubscriptionFilterQueryContainer::operator=(
           const SubscriptionFilterQueryContainer& container)
   {
       if (this == &container)
 { {
     return(new SubscriptionFilterConditionContainer(_rep->filterCondition,          return *this;
         _rep->queryLanguage));  
 } }
  
 void SubscriptionFilterConditionContainer::destroy(void)      _rep->filterQuery = container._rep->filterQuery;
       _rep->queryLanguage = container._rep->queryLanguage;
       _rep->sourceNameSpace = container._rep->sourceNameSpace;
   
       return *this;
   }
   
   String SubscriptionFilterQueryContainer::getName() const
   {
       return NAME;
   }
   
   OperationContext::Container* SubscriptionFilterQueryContainer::clone() const
   {
       return new SubscriptionFilterQueryContainer(
           _rep->filterQuery,
           _rep->queryLanguage,
           _rep->sourceNameSpace);
   }
   
   void SubscriptionFilterQueryContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 String SubscriptionFilterConditionContainer::getFilterCondition(void) const  String SubscriptionFilterQueryContainer::getFilterQuery() const
   {
       return _rep->filterQuery;
   }
   
   String SubscriptionFilterQueryContainer::getQueryLanguage() const
 { {
     return(_rep->filterCondition);      return _rep->queryLanguage;
 } }
  
 String SubscriptionFilterConditionContainer::getQueryLanguage(void) const  CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace() const
 { {
     return(_rep->queryLanguage);      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)
 { {
    const TimeoutContainer * p = dynamic_cast<const TimeoutContainer *>(&container);      const TimeoutContainer* p =
           dynamic_cast<const TimeoutContainer*>(&container);
    if(p == 0)    if(p == 0)
    {    {
       throw DynamicCastFailedException();       throw DynamicCastFailedException();
Line 567 
Line 676 
    _value = timeout;    _value = timeout;
 } }
  
 String TimeoutContainer::getName(void) const  String TimeoutContainer::getName() const
 { {
    return (NAME);      return NAME;
 } }
  
 OperationContext::Container * TimeoutContainer::clone(void) const  OperationContext::Container* TimeoutContainer::clone() const
 { {
    return (new TimeoutContainer(_value));      return new TimeoutContainer(_value);
 } }
  
 void TimeoutContainer::destroy(void)  void TimeoutContainer::destroy()
 { {
    delete this;    delete this;
 } }
  
 Uint32 TimeoutContainer::getTimeOut(void) const  Uint32 TimeoutContainer::getTimeOut() const
 { {
    return _value;    return _value;
 } }
  
  
   //
   // 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)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : OperationContext::Container()
   #endif
   {
       _rep = new AcceptLanguageListContainerRep();
       _rep->languages = container._rep->languages;
   }
   
   AcceptLanguageListContainer::AcceptLanguageListContainer(
       const AcceptLanguageList& languages)
   {
       _rep = new AcceptLanguageListContainerRep();
       _rep->languages = languages;
   }
   
   AcceptLanguageListContainer::~AcceptLanguageListContainer()
   {
       delete _rep;
   }
   
   AcceptLanguageListContainer& AcceptLanguageListContainer::operator=(
       const AcceptLanguageListContainer& container)
   {
       if (this == &container)
       {
           return *this;
       }
   
       _rep->languages = container._rep->languages;
   
       return *this;
   }
   
   String AcceptLanguageListContainer::getName() const
   {
       return NAME;
   }
   
   OperationContext::Container* AcceptLanguageListContainer::clone() const
   {
       return new AcceptLanguageListContainer(_rep->languages);
   }
   
   void AcceptLanguageListContainer::destroy()
   {
       delete this;
   }
   
   AcceptLanguageList AcceptLanguageListContainer::getLanguages() 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)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : OperationContext::Container()
   #endif
   {
       _rep = new ContentLanguageListContainerRep();
       _rep->languages = container._rep->languages;
   }
   
   ContentLanguageListContainer::ContentLanguageListContainer(
       const ContentLanguageList& languages)
   {
       _rep = new ContentLanguageListContainerRep();
       _rep->languages = languages;
   }
   
   ContentLanguageListContainer::~ContentLanguageListContainer()
   {
       delete _rep;
   }
   
   ContentLanguageListContainer& ContentLanguageListContainer::operator=(
       const ContentLanguageListContainer& container)
   {
       if (this == &container)
       {
           return *this;
       }
   
       _rep->languages = container._rep->languages;
   
       return *this;
   }
   
   String ContentLanguageListContainer::getName() const
   {
       return NAME;
   }
   
   OperationContext::Container* ContentLanguageListContainer::clone() const
   {
       return new ContentLanguageListContainer(_rep->languages);
   }
   
   void ContentLanguageListContainer::destroy()
   {
       delete this;
   }
   
   ContentLanguageList ContentLanguageListContainer::getLanguages() 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)
   #ifdef PEGASUS_INCLUDE_SUPERCLASS_INITIALIZER
       : OperationContext::Container()
   #endif
   {
       _rep = new SnmpTrapOidContainerRep();
       _rep->snmpTrapOid = container._rep->snmpTrapOid;
   }
   
   SnmpTrapOidContainer::SnmpTrapOidContainer(const String& snmpTrapOid)
   {
       _rep = new SnmpTrapOidContainerRep();
       _rep->snmpTrapOid = snmpTrapOid;
   }
   
   SnmpTrapOidContainer::~SnmpTrapOidContainer()
   {
       delete _rep;
   }
   
   SnmpTrapOidContainer& SnmpTrapOidContainer::operator=(
       const SnmpTrapOidContainer& container)
   {
       if (this == &container)
       {
           return *this;
       }
   
       _rep->snmpTrapOid = container._rep->snmpTrapOid;
   
       return *this;
   }
   
   String SnmpTrapOidContainer::getName() const
   {
       return NAME;
   }
   
   OperationContext::Container* SnmpTrapOidContainer::clone() const
   {
       return new SnmpTrapOidContainer(_rep->snmpTrapOid);
   }
   
   void SnmpTrapOidContainer::destroy()
   {
       delete this;
   }
   
   String SnmpTrapOidContainer::getSnmpTrapOid() const
   {
       return _rep->snmpTrapOid;
   }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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