1 karl  1.25 //%2006////////////////////////////////////////////////////////////////////////

  2 mike  1.9  //

  3 karl  1.23 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
  4            // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
  5            // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;

  6 karl  1.22 // IBM Corp.; EMC Corporation, The Open Group.

  7 karl  1.23 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8            // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

  9 karl  1.24 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10            // EMC Corporation; VERITAS Software Corporation; The Open Group.

 11 karl  1.25 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 12            // EMC Corporation; Symantec Corporation; The Open Group.

 13 mike  1.9  //
 14            // Permission is hereby granted, free of charge, to any person obtaining a copy

 15 kumpf 1.15 // of this software and associated documentation files (the "Software"), to
 16            // deal in the Software without restriction, including without limitation the
 17            // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 18 mike  1.9  // sell copies of the Software, and to permit persons to whom the Software is
 19            // furnished to do so, subject to the following conditions:
 20            // 

 21 kumpf 1.15 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

 22 mike  1.9  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 23            // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

 24 kumpf 1.15 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 25            // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 26            // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 27 mike  1.9  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 28            // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 29            //
 30            //==============================================================================
 31            //
 32            //%/////////////////////////////////////////////////////////////////////////////
 33            
 34            #include "CIMQualifierDecl.h"

 35 kumpf 1.10 #include "CIMQualifierDeclRep.h"

 36 mike  1.9  
 37            PEGASUS_NAMESPACE_BEGIN
 38            
 39            #define PEGASUS_ARRAY_T CIMQualifierDecl
 40            # include "ArrayImpl.h"
 41            #undef PEGASUS_ARRAY_T
 42            

 43 kumpf 1.10 ////////////////////////////////////////////////////////////////////////////////
 44            //
 45            // CIMQualifierDecl
 46            //
 47            ////////////////////////////////////////////////////////////////////////////////
 48            
 49            CIMQualifierDecl::CIMQualifierDecl()
 50                : _rep(0)
 51            {
 52            }
 53            
 54            CIMQualifierDecl::CIMQualifierDecl(const CIMQualifierDecl& x)
 55            {
 56                Inc(_rep = x._rep);
 57            }
 58            
 59            CIMQualifierDecl::CIMQualifierDecl(

 60 kumpf 1.16     const CIMName& name,

 61 kumpf 1.10     const CIMValue& value,

 62 kumpf 1.19     const CIMScope & scope,
 63                const CIMFlavor & flavor,

 64 kumpf 1.10     Uint32 arraySize)
 65            {
 66                _rep = new CIMQualifierDeclRep(name, value, scope, flavor, arraySize);
 67            }
 68            
 69            CIMQualifierDecl::CIMQualifierDecl(CIMQualifierDeclRep* rep)
 70                : _rep(rep)
 71            {
 72            }
 73            
 74            CIMQualifierDecl::~CIMQualifierDecl()
 75            {
 76                Dec(_rep);
 77            }
 78            
 79            CIMQualifierDecl& CIMQualifierDecl::operator=(const CIMQualifierDecl& x)
 80            {
 81                if (x._rep != _rep)
 82                {
 83                    Dec(_rep);
 84                    Inc(_rep = x._rep);
 85 kumpf 1.10     }
 86            
 87                return *this;
 88            }
 89            

 90 kumpf 1.16 const CIMName& CIMQualifierDecl::getName() const

 91 kumpf 1.10 {

 92 marek 1.27     CheckRep(_rep);

 93 kumpf 1.10     return _rep->getName();
 94            }
 95            

 96 kumpf 1.16 void CIMQualifierDecl::setName(const CIMName& name)

 97 kumpf 1.10 {

 98 marek 1.27     CheckRep(_rep);

 99 kumpf 1.10     _rep->setName(name);
100            }
101            
102            CIMType CIMQualifierDecl::getType() const
103            {

104 marek 1.27     CheckRep(_rep);

105 kumpf 1.10     return _rep->getType();
106            }
107            
108            Boolean CIMQualifierDecl::isArray() const
109            {

110 marek 1.27     CheckRep(_rep);

111 kumpf 1.10     return _rep->isArray();
112            }
113            
114            const CIMValue& CIMQualifierDecl::getValue() const
115            {

116 marek 1.27     CheckRep(_rep);

117 kumpf 1.10     return _rep->getValue();
118            }
119            
120            void CIMQualifierDecl::setValue(const CIMValue& value)
121            {

122 marek 1.27     CheckRep(_rep);

123 kumpf 1.10     _rep->setValue(value);
124            }
125            

126 kumpf 1.18 const CIMScope & CIMQualifierDecl::getScope() const

127 kumpf 1.10 {

128 marek 1.27     CheckRep(_rep);

129 kumpf 1.10     return _rep->getScope();
130            }
131            

132 kumpf 1.19 const CIMFlavor & CIMQualifierDecl::getFlavor() const

133 kumpf 1.10 {

134 marek 1.27     CheckRep(_rep);

135 kumpf 1.10     return _rep->getFlavor();
136            }
137            
138            Uint32 CIMQualifierDecl::getArraySize() const
139            {

140 marek 1.27     CheckRep(_rep);

141 kumpf 1.10     return _rep->getArraySize();
142            }
143            

144 kumpf 1.17 Boolean CIMQualifierDecl::isUninitialized() const

145 kumpf 1.10 {

146 kumpf 1.26     return _rep == 0;

147 kumpf 1.10 }
148            

149 mike  1.9  Boolean CIMQualifierDecl::identical(const CIMConstQualifierDecl& x) const
150            {

151 marek 1.27     CheckRep(x._rep);
152                CheckRep(_rep);

153 mike  1.9      return _rep->identical(x._rep);

154 kumpf 1.10 }
155            
156            CIMQualifierDecl CIMQualifierDecl::clone() const
157            {
158                return CIMQualifierDecl(_rep->clone());
159            }
160            
161            
162            ////////////////////////////////////////////////////////////////////////////////
163            //
164            // CIMConstQualifierDecl
165            //
166            ////////////////////////////////////////////////////////////////////////////////
167            
168            CIMConstQualifierDecl::CIMConstQualifierDecl()
169                : _rep(0)
170            {
171            }
172            
173            CIMConstQualifierDecl::CIMConstQualifierDecl(const CIMConstQualifierDecl& x)
174            {
175 kumpf 1.10     Inc(_rep = x._rep);
176            }
177            
178            CIMConstQualifierDecl::CIMConstQualifierDecl(const CIMQualifierDecl& x)
179            {
180                Inc(_rep = x._rep);
181            }
182            
183            CIMConstQualifierDecl::CIMConstQualifierDecl(

184 kumpf 1.16     const CIMName& name,

185 kumpf 1.10     const CIMValue& value,

186 kumpf 1.19     const CIMScope & scope,
187                const CIMFlavor & flavor,

188 kumpf 1.10     Uint32 arraySize)
189            {
190                _rep = new CIMQualifierDeclRep(name, value, scope, flavor, arraySize);
191            }
192            
193            CIMConstQualifierDecl::~CIMConstQualifierDecl()
194            {
195                Dec(_rep);
196            }
197            
198            CIMConstQualifierDecl& CIMConstQualifierDecl::operator=(
199                const CIMConstQualifierDecl& x)
200            {
201                if (x._rep != _rep)
202                {
203                    Dec(_rep);
204                    Inc(_rep = x._rep);
205                }
206            
207                return *this;
208            }
209 kumpf 1.10 
210            CIMConstQualifierDecl& CIMConstQualifierDecl::operator=(
211                const CIMQualifierDecl& x)
212            {
213                if (x._rep != _rep)
214                {
215                    Dec(_rep);
216                    Inc(_rep = x._rep);
217                }
218            
219                return *this;
220            }
221            

222 kumpf 1.16 const CIMName& CIMConstQualifierDecl::getName() const

223 kumpf 1.10 {

224 marek 1.27     CheckRep(_rep);

225 kumpf 1.10     return _rep->getName();
226            }
227            
228            CIMType CIMConstQualifierDecl::getType() const
229            {

230 marek 1.27     CheckRep(_rep);

231 kumpf 1.10     return _rep->getType();
232            }
233            
234            Boolean CIMConstQualifierDecl::isArray() const
235            {

236 marek 1.27     CheckRep(_rep);

237 kumpf 1.10     return _rep->isArray();
238            }
239            
240            const CIMValue& CIMConstQualifierDecl::getValue() const
241            {

242 marek 1.27     CheckRep(_rep);

243 kumpf 1.10     return _rep->getValue();
244            }
245            

246 kumpf 1.18 const CIMScope & CIMConstQualifierDecl::getScope() const

247 kumpf 1.10 {

248 marek 1.27     CheckRep(_rep);

249 kumpf 1.10     return _rep->getScope();
250            }
251            

252 kumpf 1.19 const CIMFlavor & CIMConstQualifierDecl::getFlavor() const

253 kumpf 1.10 {

254 marek 1.27     CheckRep(_rep);

255 kumpf 1.10     return _rep->getFlavor();
256            }
257            
258            Uint32 CIMConstQualifierDecl::getArraySize() const
259            {

260 marek 1.27     CheckRep(_rep);

261 kumpf 1.10     return _rep->getArraySize();
262            }
263            

264 kumpf 1.17 Boolean CIMConstQualifierDecl::isUninitialized() const

265 kumpf 1.10 {

266 kumpf 1.26     return _rep == 0;

267 kumpf 1.10 }
268            
269            Boolean CIMConstQualifierDecl::identical(const CIMConstQualifierDecl& x) const
270            {

271 marek 1.27     CheckRep(x._rep);
272                CheckRep(_rep);

273 kumpf 1.10     return _rep->identical(x._rep);
274            }
275            
276            CIMQualifierDecl CIMConstQualifierDecl::clone() const
277            {
278                return CIMQualifierDecl(_rep->clone());
279            }
280            

281 mike  1.9  PEGASUS_NAMESPACE_END