(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.29 and 1.41

version 1.29, 2005/01/30 07:43:25 version 1.41, 2007/01/10 21:14:48
Line 1 
Line 1 
 //%2004////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 6 
Line 6 
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // 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 25 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // 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)  
 //              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  #include <Pegasus/Common/MessageLoader.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 51 
Line 47 
     Array<OperationContext::Container *> containers;     Array<OperationContext::Container *> containers;
 }; };
  
 OperationContext::OperationContext(void)  OperationContext::OperationContext()
 { {
     _rep = new OperationContextRep;     _rep = new OperationContextRep;
 } }
Line 62 
Line 58 
     *this = context;     *this = context;
 } }
  
 OperationContext::~OperationContext(void)  OperationContext::~OperationContext()
 { {
     clear();     clear();
     delete _rep;     delete _rep;
Line 72 
Line 68 
 { {
     if(this == &context)     if(this == &context)
     {     {
         return(*this);          return *this;
     }     }
  
     clear();     clear();
Line 82 
Line 78 
         _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 98 
Line 94 
 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())  
         {      for (; size--; data++)
             Container * p = _rep->containers[i];          if (data[0]->getName() == containerName)
               return *(data[0]);
  
             return(*p);      static Exception _exception(MessageLoaderParms(
           "Common.OperationContext.OBJECT_NOT_FOUND", "object not found"));
   
       throw Exception(_exception);
         }         }
   
   Boolean OperationContext::contains(
       const String& containerName) const
   {
       Uint32 size = _rep->containers.size();
       Container** data = (Container**)_rep->containers.getData();
   
       for (; size--; data++)
       {
           if (data[0]->getName() == containerName)
               return true;
     }     }
  
         //l10n      return false;
         MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",  
                                                          "object not found");  
     throw Exception(parms);  
     //throw Exception("object not found");  
 } }
  
 void OperationContext::set(const OperationContext::Container & container) void OperationContext::set(const OperationContext::Container & container)
Line 132 
Line 139 
         }         }
     }     }
  
         //l10n      MessageLoaderParms parms(
         MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",          "Common.OperationContext.OBJECT_NOT_FOUND",
                                                          "object not found");                                                          "object not found");
     throw Exception(parms);     throw Exception(parms);
     //throw Exception("object not found");  
 } }
  
 void OperationContext::insert(const OperationContext::Container & container) void OperationContext::insert(const OperationContext::Container & container)
Line 145 
Line 151 
     {     {
         if(container.getName() == _rep->containers[i]->getName())         if(container.getName() == _rep->containers[i]->getName())
         {         {
                 //l10n              MessageLoaderParms parms(
                         MessageLoaderParms parms("Common.OperationContext.OBJECT_ALREADY_EXISTS",                  "Common.OperationContext.OBJECT_ALREADY_EXISTS",
                                                          "object already exists.");                                                          "object already exists.");
                 throw Exception(parms);                 throw Exception(parms);
             //throw Exception("object already exists.");  
         }         }
     }     }
  
Line 169 
Line 174 
         }         }
     }     }
  
         //l10n      MessageLoaderParms parms(
         MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",          "Common.OperationContext.OBJECT_NOT_FOUND",
                                                          "object not found");                                                          "object not found");
     throw Exception(parms);     throw Exception(parms);
     //throw Exception("object not found");  
 } }
  
  
Line 181 
Line 185 
 // OperationContext::Container // OperationContext::Container
 // //
  
 OperationContext::Container::~Container(void)  OperationContext::Container::~Container()
 { {
 } }
  
Line 198 
Line 202 
  
 const String IdentityContainer::NAME = "IdentityContainer"; const String IdentityContainer::NAME = "IdentityContainer";
  
 IdentityContainer::IdentityContainer(const OperationContext::Container & container)  IdentityContainer::IdentityContainer(
       const OperationContext::Container& container)
 { {
     const IdentityContainer * p = dynamic_cast<const IdentityContainer *>(&container);      const IdentityContainer* p =
           dynamic_cast<const IdentityContainer*>(&container);
  
     if(p == 0)     if(p == 0)
     {     {
Line 212 
Line 218 
 } }
  
 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;
Line 223 
Line 233 
     _rep->userName = userName;     _rep->userName = userName;
 } }
  
 IdentityContainer::~IdentityContainer(void)  IdentityContainer::~IdentityContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 233 
Line 243 
 { {
     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;
 } }
  
 // Unimplemented, hidden constructor not intended for actual use  
 IdentityContainer::IdentityContainer()  
 {  
 }  
  
 // //
 // SubscriptionInstanceContainer // SubscriptionInstanceContainer
Line 279 
Line 285 
 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 294 
Line 300 
     _rep->subscriptionInstance = p->_rep->subscriptionInstance;     _rep->subscriptionInstance = p->_rep->subscriptionInstance;
 } }
  
 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;
 } }
  
 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 318 
Line 328 
 { {
     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;
 } }
  
 // Unimplemented, hidden constructor not intended for actual use  
 SubscriptionInstanceContainer::SubscriptionInstanceContainer()  
 {  
 }  
  
 // //
 // SubscriptionInstanceNamesContainer // SubscriptionInstanceNamesContainer
Line 364 
Line 370 
 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 379 
Line 385 
     _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;     _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;
 } }
  
 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;
 } }
  
 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 404 
Line 414 
 { {
     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;
 } }
  
 // Unimplemented, hidden constructor not intended for actual use  
 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer()  
 {  
 }  
  
 // //
 // SubscriptionFilterConditionContainer // SubscriptionFilterConditionContainer
Line 454 
Line 460 
 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 470 
Line 476 
     _rep->queryLanguage = p->_rep->queryLanguage;     _rep->queryLanguage = p->_rep->queryLanguage;
 } }
  
 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 487 
Line 497 
     _rep->queryLanguage = queryLanguage;     _rep->queryLanguage = queryLanguage;
 } }
  
 SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer  SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer()
     (void)  
 { {
     delete _rep;     delete _rep;
 } }
Line 499 
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(void) const  String SubscriptionFilterConditionContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * SubscriptionFilterConditionContainer::clone(void) const  OperationContext::Container* SubscriptionFilterConditionContainer::clone() const
 { {
     return(new SubscriptionFilterConditionContainer(_rep->filterCondition,      return new SubscriptionFilterConditionContainer(
         _rep->queryLanguage));          _rep->filterCondition, _rep->queryLanguage);
 } }
  
 void SubscriptionFilterConditionContainer::destroy(void)  void SubscriptionFilterConditionContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 String SubscriptionFilterConditionContainer::getFilterCondition(void) const  String SubscriptionFilterConditionContainer::getFilterCondition() const
 { {
     return(_rep->filterCondition);      return _rep->filterCondition;
 } }
  
 String SubscriptionFilterConditionContainer::getQueryLanguage(void) const  String SubscriptionFilterConditionContainer::getQueryLanguage() const
 { {
     return(_rep->queryLanguage);      return _rep->queryLanguage;
 } }
  
 // Unimplemented, hidden constructor not intended for actual use  
 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer()  
 {  
 }  
  
 // //
 // SubscriptionFilterQueryContainer // SubscriptionFilterQueryContainer
Line 554 
Line 559 
 const String SubscriptionFilterQueryContainer::NAME = const String SubscriptionFilterQueryContainer::NAME =
     "SubscriptionFilterQueryContainer";     "SubscriptionFilterQueryContainer";
  
 SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer  SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const SubscriptionFilterQueryContainer * p =     const SubscriptionFilterQueryContainer * p =
         dynamic_cast<const SubscriptionFilterQueryContainer *>(&container);         dynamic_cast<const SubscriptionFilterQueryContainer *>(&container);
Line 571 
Line 576 
     _rep->sourceNameSpace = p->_rep->sourceNameSpace;     _rep->sourceNameSpace = p->_rep->sourceNameSpace;
 } }
  
 SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer  SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
     (const SubscriptionFilterQueryContainer & container)      const SubscriptionFilterQueryContainer& container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
       defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
       : OperationContext::Container()
   #endif
 { {
     _rep = new SubscriptionFilterQueryContainerRep();     _rep = new SubscriptionFilterQueryContainerRep();
     _rep->filterQuery = container._rep->filterQuery;     _rep->filterQuery = container._rep->filterQuery;
Line 591 
Line 600 
     _rep->sourceNameSpace = sourceNameSpace;     _rep->sourceNameSpace = sourceNameSpace;
 } }
  
 SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer  SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer()
     (void)  
 { {
     delete _rep;     delete _rep;
 } }
   
 SubscriptionFilterQueryContainer & SubscriptionFilterQueryContainer &
     SubscriptionFilterQueryContainer::operator=(     SubscriptionFilterQueryContainer::operator=(
     const SubscriptionFilterQueryContainer & container)     const SubscriptionFilterQueryContainer & container)
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->filterQuery = container._rep->filterQuery;     _rep->filterQuery = container._rep->filterQuery;
     _rep->queryLanguage = container._rep->queryLanguage;     _rep->queryLanguage = container._rep->queryLanguage;
     _rep->sourceNameSpace = container._rep->sourceNameSpace;     _rep->sourceNameSpace = container._rep->sourceNameSpace;
  
     return (*this);      return *this;
 } }
  
 String SubscriptionFilterQueryContainer::getName(void) const  String SubscriptionFilterQueryContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * SubscriptionFilterQueryContainer::clone(void) const  OperationContext::Container* SubscriptionFilterQueryContainer::clone() const
 { {
     return(new SubscriptionFilterQueryContainer(_rep->filterQuery,      return new SubscriptionFilterQueryContainer(
           _rep->filterQuery,
                                                 _rep->queryLanguage,                                                 _rep->queryLanguage,
                                                 _rep->sourceNameSpace));          _rep->sourceNameSpace);
 } }
  
 void SubscriptionFilterQueryContainer::destroy(void)  void SubscriptionFilterQueryContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 String SubscriptionFilterQueryContainer::getFilterQuery(void) const  String SubscriptionFilterQueryContainer::getFilterQuery() const
 { {
     return(_rep->filterQuery);      return _rep->filterQuery;
 } }
  
 String SubscriptionFilterQueryContainer::getQueryLanguage(void) const  String SubscriptionFilterQueryContainer::getQueryLanguage() const
 { {
     return(_rep->queryLanguage);      return _rep->queryLanguage;
 } }
  
 CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace(void) const  CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace() const
 { {
     return(_rep->sourceNameSpace);      return _rep->sourceNameSpace;
 } }
  
 // Unimplemented, hidden constructor not intended for actual use  
 SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer()  
 {  
 }  
  
 // //
 // TimeoutContainer // TimeoutContainer
Line 657 
Line 663 
  
 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 670 
Line 677 
    _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;
 } }
  
  
 // l10n start  
   
 // //
 // AcceptLanguageListContainer // AcceptLanguageListContainer
 // //
Line 700 
Line 705 
 class AcceptLanguageListContainerRep class AcceptLanguageListContainerRep
 { {
 public: public:
     AcceptLanguages languages;      AcceptLanguageList languages;
 }; };
  
 const String AcceptLanguageListContainer::NAME = const String AcceptLanguageListContainer::NAME =
     "AcceptLanguageListContainer";     "AcceptLanguageListContainer";
  
 AcceptLanguageListContainer::AcceptLanguageListContainer  AcceptLanguageListContainer::AcceptLanguageListContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const AcceptLanguageListContainer * p =     const AcceptLanguageListContainer * p =
         dynamic_cast<const AcceptLanguageListContainer *>(&container);         dynamic_cast<const AcceptLanguageListContainer *>(&container);
Line 721 
Line 726 
     _rep->languages = p->_rep->languages;     _rep->languages = p->_rep->languages;
 } }
  
 AcceptLanguageListContainer::AcceptLanguageListContainer  AcceptLanguageListContainer::AcceptLanguageListContainer(
     (const AcceptLanguageListContainer & container)      const AcceptLanguageListContainer& container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
       defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
       : OperationContext::Container()
   #endif
 { {
     _rep = new AcceptLanguageListContainerRep();     _rep = new AcceptLanguageListContainerRep();
     _rep->languages = container._rep->languages;     _rep->languages = container._rep->languages;
 } }
  
 AcceptLanguageListContainer::AcceptLanguageListContainer  AcceptLanguageListContainer::AcceptLanguageListContainer(
     (const AcceptLanguages & languages)      const AcceptLanguageList& languages)
 { {
     _rep = new AcceptLanguageListContainerRep();     _rep = new AcceptLanguageListContainerRep();
     _rep->languages = languages;     _rep->languages = languages;
 } }
  
 AcceptLanguageListContainer::~AcceptLanguageListContainer(void)  AcceptLanguageListContainer::~AcceptLanguageListContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 745 
Line 754 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->languages = container._rep->languages;     _rep->languages = container._rep->languages;
  
     return (*this);      return *this;
 } }
  
 String AcceptLanguageListContainer::getName(void) const  String AcceptLanguageListContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * AcceptLanguageListContainer::clone(void) const  OperationContext::Container* AcceptLanguageListContainer::clone() const
 { {
     return(new AcceptLanguageListContainer(_rep->languages));      return new AcceptLanguageListContainer(_rep->languages);
 } }
  
 void AcceptLanguageListContainer::destroy(void)  void AcceptLanguageListContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 AcceptLanguages AcceptLanguageListContainer::getLanguages(void) const  AcceptLanguageList AcceptLanguageListContainer::getLanguages() const
 { {
     return(_rep->languages);      return _rep->languages;
 } }
  
 // Unimplemented, hidden constructor not intended for actual use  
 AcceptLanguageListContainer::AcceptLanguageListContainer()  
 {  
 }  
   
 //  
 // SubscriptionLanguageListContainer  
 //  
   
 class SubscriptionLanguageListContainerRep  
 {  
 public:  
     AcceptLanguages languages;  
 };  
   
 const String SubscriptionLanguageListContainer::NAME =  
     "SubscriptionLanguageListContainer";  
   
 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer  
     (const OperationContext::Container & container)  
 {  
     const SubscriptionLanguageListContainer * p =  
         dynamic_cast<const SubscriptionLanguageListContainer *>(&container);  
   
     if(p == 0)  
     {  
         throw DynamicCastFailedException();  
     }  
   
     _rep = new SubscriptionLanguageListContainerRep();  
     _rep->languages = p->_rep->languages;  
 }  
   
 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer  
     (const SubscriptionLanguageListContainer & container)  
 {  
     _rep = new SubscriptionLanguageListContainerRep();  
     _rep->languages = container._rep->languages;  
 }  
   
 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer  
     (const AcceptLanguages & languages)  
 {  
     _rep = new SubscriptionLanguageListContainerRep();  
     _rep->languages = languages;  
 }  
   
 SubscriptionLanguageListContainer::~SubscriptionLanguageListContainer(void)  
 {  
     delete _rep;  
 }  
   
 SubscriptionLanguageListContainer & SubscriptionLanguageListContainer::operator=(  
     const SubscriptionLanguageListContainer & container)  
 {  
     if (this == &container)  
     {  
         return (*this);  
     }  
   
     _rep->languages = container._rep->languages;  
   
     return (*this);  
 }  
   
 String SubscriptionLanguageListContainer::getName(void) const  
 {  
     return(NAME);  
 }  
   
 OperationContext::Container * SubscriptionLanguageListContainer::clone(void) const  
 {  
     return(new SubscriptionLanguageListContainer(_rep->languages));  
 }  
   
 void SubscriptionLanguageListContainer::destroy(void)  
 {  
     delete this;  
 }  
   
 AcceptLanguages SubscriptionLanguageListContainer::getLanguages(void) const  
 {  
     return(_rep->languages);  
 }  
   
 // Unimplemented, hidden constructor not intended for actual use  
 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer()  
 {  
 }  
  
 // //
 // ContentLanguageListContainer // ContentLanguageListContainer
Line 870 
Line 790 
 class ContentLanguageListContainerRep class ContentLanguageListContainerRep
 { {
 public: public:
     ContentLanguages languages;      ContentLanguageList languages;
 }; };
  
 const String ContentLanguageListContainer::NAME = const String ContentLanguageListContainer::NAME =
     "ContentLanguageListContainer";     "ContentLanguageListContainer";
  
 ContentLanguageListContainer::ContentLanguageListContainer  ContentLanguageListContainer::ContentLanguageListContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const ContentLanguageListContainer * p =     const ContentLanguageListContainer * p =
         dynamic_cast<const ContentLanguageListContainer *>(&container);         dynamic_cast<const ContentLanguageListContainer *>(&container);
Line 891 
Line 811 
     _rep->languages = p->_rep->languages;     _rep->languages = p->_rep->languages;
 } }
  
 ContentLanguageListContainer::ContentLanguageListContainer  ContentLanguageListContainer::ContentLanguageListContainer(
     (const ContentLanguageListContainer & container)      const ContentLanguageListContainer& container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
       defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
       : OperationContext::Container()
   #endif
 { {
     _rep = new ContentLanguageListContainerRep();     _rep = new ContentLanguageListContainerRep();
     _rep->languages = container._rep->languages;     _rep->languages = container._rep->languages;
 } }
  
 ContentLanguageListContainer::ContentLanguageListContainer  ContentLanguageListContainer::ContentLanguageListContainer(
     (const ContentLanguages & languages)      const ContentLanguageList& languages)
 { {
     _rep = new ContentLanguageListContainerRep();     _rep = new ContentLanguageListContainerRep();
     _rep->languages = languages;     _rep->languages = languages;
 } }
  
 ContentLanguageListContainer::~ContentLanguageListContainer(void)  ContentLanguageListContainer::~ContentLanguageListContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 915 
Line 839 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->languages = container._rep->languages;     _rep->languages = container._rep->languages;
  
     return (*this);      return *this;
 } }
  
 String ContentLanguageListContainer::getName(void) const  String ContentLanguageListContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * ContentLanguageListContainer::clone(void) const  OperationContext::Container* ContentLanguageListContainer::clone() const
 { {
     return(new ContentLanguageListContainer(_rep->languages));      return new ContentLanguageListContainer(_rep->languages);
 } }
  
 void ContentLanguageListContainer::destroy(void)  void ContentLanguageListContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 ContentLanguages ContentLanguageListContainer::getLanguages(void) const  ContentLanguageList ContentLanguageListContainer::getLanguages() const
 {  
     return(_rep->languages);  
 }  
   
 // Unimplemented, hidden constructor not intended for actual use  
 ContentLanguageListContainer::ContentLanguageListContainer()  
 { {
       return _rep->languages;
 } }
  
 // l10n end  
  
 // //
 // SnmpTrapOidContainer // SnmpTrapOidContainer
Line 963 
Line 881 
 const String SnmpTrapOidContainer::NAME = const String SnmpTrapOidContainer::NAME =
     "SnmpTrapOidContainer";     "SnmpTrapOidContainer";
  
 SnmpTrapOidContainer::SnmpTrapOidContainer  SnmpTrapOidContainer::SnmpTrapOidContainer(
     (const OperationContext::Container & container)      const OperationContext::Container& container)
 { {
     const SnmpTrapOidContainer * p =     const SnmpTrapOidContainer * p =
         dynamic_cast<const SnmpTrapOidContainer *>(&container);         dynamic_cast<const SnmpTrapOidContainer *>(&container);
Line 978 
Line 896 
     _rep->snmpTrapOid = p->_rep->snmpTrapOid;     _rep->snmpTrapOid = p->_rep->snmpTrapOid;
 } }
  
 SnmpTrapOidContainer::SnmpTrapOidContainer  SnmpTrapOidContainer::SnmpTrapOidContainer(
     (const SnmpTrapOidContainer & container)      const SnmpTrapOidContainer& container)
   #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
       defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
       : OperationContext::Container()
   #endif
 { {
     _rep = new SnmpTrapOidContainerRep();     _rep = new SnmpTrapOidContainerRep();
     _rep->snmpTrapOid = container._rep->snmpTrapOid;     _rep->snmpTrapOid = container._rep->snmpTrapOid;
 } }
  
 SnmpTrapOidContainer::SnmpTrapOidContainer  SnmpTrapOidContainer::SnmpTrapOidContainer(const String& snmpTrapOid)
     (const String & snmpTrapOid)  
 { {
     _rep = new SnmpTrapOidContainerRep();     _rep = new SnmpTrapOidContainerRep();
     _rep->snmpTrapOid = snmpTrapOid;     _rep->snmpTrapOid = snmpTrapOid;
 } }
  
 SnmpTrapOidContainer::~SnmpTrapOidContainer(void)  SnmpTrapOidContainer::~SnmpTrapOidContainer()
 { {
     delete _rep;     delete _rep;
 } }
Line 1002 
Line 923 
 { {
     if (this == &container)     if (this == &container)
     {     {
         return (*this);          return *this;
     }     }
  
     _rep->snmpTrapOid = container._rep->snmpTrapOid;     _rep->snmpTrapOid = container._rep->snmpTrapOid;
  
     return (*this);      return *this;
 } }
  
 String SnmpTrapOidContainer::getName(void) const  String SnmpTrapOidContainer::getName() const
 { {
     return(NAME);      return NAME;
 } }
  
 OperationContext::Container * SnmpTrapOidContainer::clone(void) const  OperationContext::Container* SnmpTrapOidContainer::clone() const
 { {
     return(new SnmpTrapOidContainer(_rep->snmpTrapOid));      return new SnmpTrapOidContainer(_rep->snmpTrapOid);
 } }
  
 void SnmpTrapOidContainer::destroy(void)  void SnmpTrapOidContainer::destroy()
 { {
     delete this;     delete this;
 } }
  
 String SnmpTrapOidContainer::getSnmpTrapOid(void) const  String SnmpTrapOidContainer::getSnmpTrapOid() const
 {  
     return(_rep->snmpTrapOid);  
 }  
   
 // Unimplemented, hidden constructor not intended for actual use  
 SnmpTrapOidContainer::SnmpTrapOidContainer()  
 { {
       return _rep->snmpTrapOid;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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