1 mike  1.6 //%/////////////////////////////////////////////////////////////////////////////

  2 mike  1.1 //
  3           // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM
  4           //
  5           // Permission is hereby granted, free of charge, to any person obtaining a
  6           // copy of this software and associated documentation files (the "Software"),
  7           // to deal in the Software without restriction, including without limitation
  8           // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9           // and/or sell copies of the Software, and to permit persons to whom the
 10           // Software is furnished to do so, subject to the following conditions:
 11           //
 12           // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 13           // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 14           // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 15           // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 16           // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 17           // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 18           // DEALINGS IN THE SOFTWARE.
 19           //

 20 mike  1.6 //==============================================================================

 21 mike  1.1 //

 22 mike  1.6 // Author: Mike Brasher (mbrasher@bmc.com)

 23 mike  1.1 //

 24 mike  1.6 // Modified By:

 25 bob   1.4 //

 26 mike  1.6 //%/////////////////////////////////////////////////////////////////////////////

 27 mike  1.1 
 28           #ifndef Pegasus_PropertyRep_h
 29           #define Pegasus_PropertyRep_h
 30           
 31           #include <Pegasus/Common/Config.h>
 32           #include <Pegasus/Common/Exception.h>
 33           #include <Pegasus/Common/String.h>
 34           #include <Pegasus/Common/CIMValue.h>
 35           #include <Pegasus/Common/CIMQualifier.h>
 36           #include <Pegasus/Common/CIMQualifierList.h>
 37           #include <Pegasus/Common/Sharable.h>
 38           #include <Pegasus/Common/Pair.h>
 39           
 40           PEGASUS_NAMESPACE_BEGIN
 41           
 42           class CIMClassRep;
 43           class CIMProperty;

 44 mike  1.5 class CIMConstProperty;

 45 mike  1.1 class DeclContext;
 46           
 47           class PEGASUS_COMMON_LINKAGE CIMPropertyRep : public Sharable
 48           {
 49           public:
 50           
 51               CIMPropertyRep(
 52           	const String& name, 
 53           	const CIMValue& value,
 54           	Uint32 arraySize,
 55           	const String& referenceClassName,
 56           	const String& classOrigin,
 57           	Boolean propagated);
 58           
 59               ~CIMPropertyRep();
 60           
 61               const String& getName() const 
 62               { 
 63           	return _name; 
 64               }
 65           
 66 mike  1.1     void setName(const String& name);
 67           
 68               const CIMValue& getValue() const 
 69               { 
 70           	return _value; 
 71               }
 72           
 73               void setValue(const CIMValue& value);
 74           
 75               Uint32 getArraySize() const
 76               {
 77           	return _arraySize;
 78               }
 79           
 80               const String& getReferenceClassName() const 
 81               {
 82           	return _referenceClassName; 
 83               }
 84           
 85               const String& getClassOrigin() const 
 86               { 
 87 mike  1.1 	return _classOrigin; 
 88               }
 89           
 90               void setClassOrigin(const String& classOrigin);
 91           
 92               Boolean getPropagated() const 
 93               { 
 94           	return _propagated; 
 95               }
 96           
 97               void setPropagated(Boolean propagated) 
 98               { 
 99           	_propagated = propagated; 
100               }
101           
102               void addQualifier(const CIMQualifier& qualifier)
103               {
104           	_qualifiers.add(qualifier);
105               }
106           
107               Uint32 findQualifier(const String& name) const
108 mike  1.1     {
109           	return _qualifiers.find(name);
110               }
111           

112 karl  1.8     Boolean existsQualifier(const String& name) const
113               {

114 mike  1.9 	return (findQualifier(name) != Uint32(-1)) ? true : false;

115 karl  1.8     }
116           

117 mike  1.1     CIMQualifier getQualifier(Uint32 pos)
118               {
119           	return _qualifiers.getQualifier(pos);
120               }
121           
122               CIMConstQualifier getQualifier(Uint32 pos) const
123               {
124           	return _qualifiers.getQualifier(pos);

125 karl  1.8     }
126           
127               void removeQualifier(Uint32 pos)
128               {
129           	_qualifiers.removeQualifier(pos);

130 mike  1.1     }
131           
132               Uint32 getQualifierCount() const
133               {
134           	return _qualifiers.getCount();
135               }
136           
137               void resolve(
138           	DeclContext* declContext, 
139           	const String& nameSpace,
140           	Boolean isInstancePart,

141 mike  1.5 	const CIMConstProperty& property);

142 mike  1.1 
143               void resolve(
144           	DeclContext* declContext, 
145           	const String& nameSpace,
146           	Boolean isInstancePart);
147           
148               void toXml(Array<Sint8>& out) const;
149           

150 mike  1.7     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const;

151 mike  1.1 
152               Boolean identical(const CIMPropertyRep* x) const;

153 mike  1.3 
154               Boolean isKey() const;

155 mike  1.1 
156               CIMPropertyRep* clone() const
157               {
158           	return new CIMPropertyRep(*this);
159               }
160           
161           private:
162           
163               CIMPropertyRep();
164           
165               // Cloning constructor:
166           
167               CIMPropertyRep(const CIMPropertyRep& x);
168           
169               CIMPropertyRep& operator=(const CIMPropertyRep& x);
170           
171               String _name;
172               CIMValue _value;
173               Uint32 _arraySize;
174               String _referenceClassName;
175               String _classOrigin;
176 mike  1.1     Boolean _propagated;
177               CIMQualifierList _qualifiers;
178           
179               friend class CIMClassRep;
180           };
181           
182           PEGASUS_NAMESPACE_END
183           
184           #endif /* Pegasus_PropertyRep_h */