1 martin 1.10 //%LICENSE////////////////////////////////////////////////////////////////

  2 martin 1.11 //

  3 martin 1.10 // Licensed to The Open Group (TOG) under one or more contributor license
  4             // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
  5             // this work for additional information regarding copyright ownership.
  6             // Each contributor licenses this file to you under the OpenPegasus Open
  7             // Source License; you may not use this file except in compliance with the
  8             // License.

  9 martin 1.11 //

 10 martin 1.10 // Permission is hereby granted, free of charge, to any person obtaining a
 11             // copy of this software and associated documentation files (the "Software"),
 12             // to deal in the Software without restriction, including without limitation
 13             // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 14             // and/or sell copies of the Software, and to permit persons to whom the
 15             // Software is furnished to do so, subject to the following conditions:

 16 martin 1.11 //

 17 martin 1.10 // The above copyright notice and this permission notice shall be included
 18             // in all copies or substantial portions of the Software.

 19 martin 1.11 //

 20 martin 1.10 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 21 martin 1.11 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 22 martin 1.10 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 23             // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 24             // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 25             // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 26             // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 27 martin 1.11 //

 28 martin 1.10 //////////////////////////////////////////////////////////////////////////

 29 r.kieninger 1.2  //
 30                  //%/////////////////////////////////////////////////////////////////////////////
 31                  

 32 mike        1.3  #if !defined(Pegasus_CIMNameInline_cxx)
 33                  # if !defined(PEGASUS_INTERNALONLY) || defined(PEGASUS_DISABLE_INTERNAL_INLINES)
 34                  #   define Pegasus_CIMNameInline_h
 35                  # endif

 36 r.kieninger 1.2  #endif
 37                  
 38                  #ifndef Pegasus_CIMNameInline_h
 39                  #define Pegasus_CIMNameInline_h
 40                  
 41                  #include <Pegasus/Common/CIMName.h>
 42                  
 43                  #ifdef Pegasus_CIMNameInline_cxx
 44                  # define PEGASUS_CIMNAME_INLINE
 45                  #else
 46                  # define PEGASUS_CIMNAME_INLINE inline
 47                  #endif
 48                  
 49                  PEGASUS_NAMESPACE_BEGIN
 50                  
 51                  PEGASUS_CIMNAME_INLINE CIMName::CIMName()
 52                  {
 53                  }
 54                  
 55                  PEGASUS_CIMNAME_INLINE CIMName& CIMName::operator=(const CIMName& name)
 56                  {
 57 r.kieninger 1.2      cimName = name.cimName;
 58                      return *this;
 59                  }
 60                  
 61                  PEGASUS_CIMNAME_INLINE const String& CIMName::getString() const
 62                  {
 63                      return cimName;
 64                  }
 65                  
 66                  PEGASUS_CIMNAME_INLINE Boolean CIMName::isNull() const
 67                  {

 68 kumpf       1.5      return cimName.size() == 0;

 69 r.kieninger 1.2  }
 70                  
 71                  PEGASUS_CIMNAME_INLINE void CIMName::clear()
 72                  {
 73                      cimName.clear();
 74                  }
 75                  
 76                  PEGASUS_CIMNAME_INLINE Boolean CIMName::equal(const CIMName& name) const
 77                  {
 78                      return String::equalNoCase(cimName, name.cimName);
 79                  }
 80                  
 81                  PEGASUS_CIMNAME_INLINE Boolean CIMName::equal(const char* name) const
 82                  {
 83                      return String::equalNoCase(cimName, name);
 84                  }
 85                  
 86                  PEGASUS_CIMNAME_INLINE Boolean operator==(
 87                      const CIMName& name1, const CIMName& name2)
 88                  {
 89                      return name1.equal(name2);
 90 r.kieninger 1.2  }
 91                  
 92                  PEGASUS_CIMNAME_INLINE Boolean operator==(
 93                      const CIMName& name1, const char* name2)
 94                  {
 95                      return name1.equal(name2);
 96                  }
 97                  
 98                  PEGASUS_CIMNAME_INLINE Boolean operator==(
 99                      const char* name1, const CIMName& name2)
100                  {
101                      return name2.equal(name1);
102                  }
103                  
104                  PEGASUS_CIMNAME_INLINE Boolean operator!=(
105                      const CIMName& name1, const CIMName& name2)
106                  {
107                      return !name1.equal(name2);
108                  }
109                  
110                  PEGASUS_CIMNAME_INLINE Boolean operator!=(
111 r.kieninger 1.2      const CIMName& name1, const char* name2)
112                  {
113                      return !name1.equal(name2);
114                  }
115                  
116                  PEGASUS_CIMNAME_INLINE Boolean operator!=(
117                      const char* name1, const CIMName& name2)
118                  {
119                      return !name2.equal(name1);
120                  }
121                  
122                  PEGASUS_CIMNAME_INLINE CIMNamespaceName::CIMNamespaceName()
123                  {
124                  }
125                  
126                  PEGASUS_CIMNAME_INLINE const String& CIMNamespaceName::getString() const
127                  {
128                      return cimNamespaceName;
129                  }
130                  
131                  PEGASUS_CIMNAME_INLINE Boolean CIMNamespaceName::isNull() const
132 r.kieninger 1.2  {

133 kumpf       1.5      return cimNamespaceName.size() == 0;

134 r.kieninger 1.2  }
135                  
136                  PEGASUS_CIMNAME_INLINE void CIMNamespaceName::clear()
137                  {
138                      cimNamespaceName.clear();
139                  }
140                  
141                  PEGASUS_CIMNAME_INLINE Boolean CIMNamespaceName::equal(
142                      const CIMNamespaceName& name) const
143                  {
144                      return String::equalNoCase(cimNamespaceName, name.cimNamespaceName);
145                  }
146                  
147                  PEGASUS_CIMNAME_INLINE Boolean CIMNamespaceName::equal(const char* name) const
148                  {
149                      return String::equalNoCase(cimNamespaceName, name);
150                  }
151                  
152                  PEGASUS_NAMESPACE_END
153                  
154                  #endif /* Pegasus_CIMNameInline_h */