00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00036 #include "OW_config.h"
00037 #include "OW_CIMQualifierType.hpp"
00038 #include "OW_CIMValueCast.hpp"
00039 #include "OW_StringBuffer.hpp"
00040 #include "OW_BinarySerialization.hpp"
00041 #include "OW_StrictWeakOrdering.hpp"
00042 #include "OW_CIMScope.hpp"
00043 #include "OW_CIMDataType.hpp"
00044 #include "OW_CIMFlavor.hpp"
00045 #include "OW_CIMValue.hpp"
00046 #include "OW_COWIntrusiveCountableBase.hpp"
00047
00048 #include <algorithm>
00049
00050 namespace OW_NAMESPACE
00051 {
00052
00053 using std::istream;
00054 using std::ostream;
00055
00056 struct CIMQualifierType::QUALTData : public COWIntrusiveCountableBase
00057 {
00058 QUALTData()
00059 : m_defaultValue(CIMNULL)
00060 {}
00061 CIMName m_name;
00062 CIMDataType m_dataType;
00063 CIMScopeArray m_scope;
00064 CIMFlavorArray m_flavor;
00065 CIMValue m_defaultValue;
00066 QUALTData* clone() const { return new QUALTData(*this); }
00067 };
00069 bool operator<(const CIMQualifierType::QUALTData& x, const CIMQualifierType::QUALTData& y)
00070 {
00071 return StrictWeakOrdering(
00072 x.m_name, y.m_name,
00073 x.m_dataType, y.m_dataType,
00074 x.m_scope, y.m_scope,
00075 x.m_flavor, y.m_flavor,
00076 x.m_defaultValue, y.m_defaultValue);
00077 }
00079 bool operator<(const CIMQualifierType& x, const CIMQualifierType& y)
00080 {
00081 return *x.m_pdata < *y.m_pdata;
00082 }
00084 CIMQualifierType::CIMQualifierType() :
00085 CIMElement(), m_pdata(new QUALTData)
00086 {
00087 addFlavor(CIMFlavor::ENABLEOVERRIDE);
00088 addFlavor(CIMFlavor::TOSUBCLASS);
00089 }
00091 CIMQualifierType::CIMQualifierType(CIMNULL_t) :
00092 CIMElement(), m_pdata(0)
00093 {
00094 }
00096 CIMQualifierType::CIMQualifierType(const CIMName& name) :
00097 CIMElement(), m_pdata(new QUALTData)
00098 {
00099 m_pdata->m_name = name;
00100 addFlavor(CIMFlavor::ENABLEOVERRIDE);
00101 addFlavor(CIMFlavor::TOSUBCLASS);
00102 }
00104 CIMQualifierType::CIMQualifierType(const char* name) :
00105 CIMElement(), m_pdata(new QUALTData)
00106 {
00107 m_pdata->m_name = name;
00108 addFlavor(CIMFlavor::ENABLEOVERRIDE);
00109 addFlavor(CIMFlavor::TOSUBCLASS);
00110 }
00112 CIMQualifierType::CIMQualifierType(const CIMQualifierType& x) :
00113 CIMElement(), m_pdata(x.m_pdata)
00114 {
00115 }
00117 CIMQualifierType::~CIMQualifierType()
00118 {
00119 }
00121 CIMQualifierType&
00122 CIMQualifierType::operator= (const CIMQualifierType& x)
00123 {
00124 m_pdata = x.m_pdata;
00125 return *this;
00126 }
00128 void
00129 CIMQualifierType::setNull()
00130 {
00131 m_pdata = NULL;
00132 }
00134 const CIMScopeArray&
00135 CIMQualifierType::getScope() const
00136 {
00137 return m_pdata->m_scope;
00138 }
00140 CIMDataType
00141 CIMQualifierType::getDataType() const
00142 {
00143 return m_pdata->m_dataType;
00144 }
00146 Int32
00147 CIMQualifierType::getDataSize() const
00148 {
00149 return m_pdata->m_dataType.getSize();
00150 }
00152 CIMValue
00153 CIMQualifierType::getDefaultValue() const
00154 {
00155 return m_pdata->m_defaultValue;
00156 }
00158 CIMQualifierType&
00159 CIMQualifierType::setDataType(const CIMDataType& dataType)
00160 {
00161 m_pdata->m_dataType = dataType;
00162 if (m_pdata->m_defaultValue)
00163 {
00164 m_pdata->m_defaultValue = CIMValueCast::castValueToDataType(
00165 m_pdata->m_defaultValue, m_pdata->m_dataType);
00166 }
00167 return *this;
00168 }
00170 CIMQualifierType&
00171 CIMQualifierType::setDataType(const CIMDataType::Type& dataType)
00172 {
00173 return setDataType(CIMDataType(dataType));
00174 }
00176 CIMQualifierType&
00177 CIMQualifierType::setDefaultValue(const CIMValue& defValue)
00178 {
00179 m_pdata->m_defaultValue = defValue;
00180 if (m_pdata->m_defaultValue)
00181 {
00182 m_pdata->m_defaultValue = CIMValueCast::castValueToDataType(
00183 m_pdata->m_defaultValue, m_pdata->m_dataType);
00184 }
00185 return *this;
00186 }
00188 CIMQualifierType&
00189 CIMQualifierType::addScope(const CIMScope& newScope)
00190 {
00191 if (newScope)
00192 {
00193 if (!hasScope(newScope))
00194 {
00195 if (newScope == CIMScope::ANY)
00196 {
00197 m_pdata->m_scope.clear();
00198 }
00199 m_pdata->m_scope.append(newScope);
00200 }
00201 }
00202 return *this;
00203 }
00205 bool
00206 CIMQualifierType::hasScope(const CIMScope& scopeArg) const
00207 {
00208 if (scopeArg)
00209 {
00210 size_t tsize = m_pdata->m_scope.size();
00211 for (size_t i = 0; i < tsize; i++)
00212 {
00213 if (m_pdata->m_scope[i].getScope() == scopeArg.getScope())
00214 {
00215 return true;
00216 }
00217 }
00218 }
00219 return false;
00220 }
00222 bool
00223 CIMQualifierType::hasFlavor(const CIMFlavor& flavorArg) const
00224 {
00225 if (flavorArg)
00226 {
00227 size_t tsize = m_pdata->m_flavor.size();
00228 for (size_t i = 0; i < tsize; i++)
00229 {
00230 if (m_pdata->m_flavor[i].getFlavor() == flavorArg.getFlavor())
00231 {
00232 return true;
00233 }
00234 }
00235 }
00236 return false;
00237 }
00239 CIMQualifierType&
00240 CIMQualifierType::addFlavor(const CIMFlavor& newFlavor)
00241 {
00242 Int32 flavor = newFlavor.getFlavor();
00243 if (newFlavor)
00244 {
00245 if (!hasFlavor(newFlavor))
00246 {
00247 switch (flavor)
00248 {
00249 case CIMFlavor::ENABLEOVERRIDE:
00250 removeFlavor(CIMFlavor::DISABLEOVERRIDE);
00251 break;
00252 case CIMFlavor::DISABLEOVERRIDE:
00253 removeFlavor(CIMFlavor::ENABLEOVERRIDE);
00254 break;
00255 case CIMFlavor::RESTRICTED:
00256 removeFlavor(CIMFlavor::TOSUBCLASS);
00257 break;
00258 case CIMFlavor::TOSUBCLASS:
00259 removeFlavor(CIMFlavor::RESTRICTED);
00260 break;
00261 }
00262 m_pdata->m_flavor.append(newFlavor);
00263 }
00264 }
00265 return *this;
00266 }
00268 CIMQualifierType&
00269 CIMQualifierType::removeFlavor(const Int32 flavor)
00270 {
00271 size_t i = 0;
00272 while (i < m_pdata->m_flavor.size())
00273 {
00274 if (m_pdata->m_flavor[i].getFlavor() == flavor)
00275 {
00276 m_pdata->m_flavor.remove(i);
00277 }
00278 else
00279 {
00280 ++i;
00281 }
00282 }
00283 return *this;
00284 }
00286 CIMFlavorArray
00287 CIMQualifierType::getFlavors() const
00288 {
00289 return m_pdata->m_flavor;
00290 }
00292 bool
00293 CIMQualifierType::hasDefaultValue() const
00294 {
00295 return m_pdata->m_defaultValue ? true : false;
00296 }
00298 bool
00299 CIMQualifierType::isDefaultValueArray() const
00300 {
00301 bool isra = false;
00302 if (m_pdata->m_defaultValue)
00303 {
00304 isra = m_pdata->m_defaultValue.isArray();
00305 }
00306 return isra;
00307 }
00309 String
00310 CIMQualifierType::getName() const
00311 {
00312 return m_pdata->m_name.toString();
00313 }
00315 void
00316 CIMQualifierType::setName(const CIMName& name)
00317 {
00318 m_pdata->m_name = name;
00319 }
00321 void
00322 CIMQualifierType::writeObject(ostream &ostrm) const
00323 {
00324 CIMBase::writeSig( ostrm, OW_CIMQUALIFIERTYPESIG );
00325 m_pdata->m_name.writeObject(ostrm);
00326 m_pdata->m_dataType.writeObject(ostrm);
00327 BinarySerialization::writeArray(ostrm, m_pdata->m_scope);
00328 BinarySerialization::writeArray(ostrm, m_pdata->m_flavor);
00329 if (m_pdata->m_defaultValue)
00330 {
00331 Bool(true).writeObject(ostrm);
00332 m_pdata->m_defaultValue.writeObject(ostrm);
00333 }
00334 else
00335 {
00336 Bool(false).writeObject(ostrm);
00337 }
00338 }
00340 void
00341 CIMQualifierType::readObject(istream &istrm)
00342 {
00343 CIMName name;
00344 CIMDataType dataType(CIMNULL);
00345 CIMScopeArray scope;
00346 CIMFlavorArray flavor;
00347 CIMValue defaultValue(CIMNULL);
00348 CIMBase::readSig( istrm, OW_CIMQUALIFIERTYPESIG );
00349 name.readObject(istrm);
00350 dataType.readObject(istrm);
00351 BinarySerialization::readArray(istrm, scope);
00352 BinarySerialization::readArray(istrm, flavor);
00353 Bool isValue;
00354 isValue.readObject(istrm);
00355 if (isValue)
00356 {
00357 defaultValue.readObject(istrm);
00358 }
00359 if (!m_pdata)
00360 {
00361 m_pdata = new QUALTData;
00362 }
00363 m_pdata->m_name = name;
00364 m_pdata->m_dataType = dataType;
00365 m_pdata->m_scope = scope;
00366 m_pdata->m_flavor = flavor;
00367 m_pdata->m_defaultValue = defaultValue;
00368 }
00370 String
00371 CIMQualifierType::toString() const
00372 {
00373 return toMOF();
00374 }
00376 String
00377 CIMQualifierType::toMOF() const
00378 {
00379 size_t i;
00380 StringBuffer rv;
00381 rv = "Qualifier ";
00382 rv += m_pdata->m_name.toString();
00383 rv += " : ";
00384 rv += m_pdata->m_dataType.toMOF();
00385 if (m_pdata->m_dataType.isArrayType())
00386 {
00387 rv += '[';
00388 if (m_pdata->m_dataType.getSize() != -1)
00389 {
00390 rv += m_pdata->m_dataType.getSize();
00391 }
00392 rv += ']';
00393 }
00394 if (m_pdata->m_defaultValue)
00395 {
00396 rv += " = ";
00397 rv += m_pdata->m_defaultValue.toMOF();
00398 }
00399 if (m_pdata->m_scope.size() > 0)
00400 {
00401 rv += ", Scope(";
00402 CIMScopeArray scopes(m_pdata->m_scope);
00403 std::sort(scopes.begin(), scopes.end());
00404 for (i = 0; i < scopes.size(); i++)
00405 {
00406 if (i > 0)
00407 {
00408 rv += ',';
00409 }
00410 rv += scopes[i].toMOF();
00411 }
00412 rv += ')';
00413 }
00414 if (m_pdata->m_flavor.size() > 0)
00415 {
00416 CIMFlavorArray toPrint;
00417
00418 for (i = 0; i < m_pdata->m_flavor.size(); i++)
00419 {
00420 if (m_pdata->m_flavor[i].getFlavor() != CIMFlavor::ENABLEOVERRIDE
00421 && m_pdata->m_flavor[i].getFlavor() != CIMFlavor::TOSUBCLASS)
00422 {
00423 toPrint.push_back(m_pdata->m_flavor[i]);
00424 }
00425 }
00426 if (toPrint.size() > 0)
00427 {
00428 rv += ", Flavor(";
00429 for (i = 0; i < toPrint.size(); i++)
00430 {
00431 if (i > 0)
00432 {
00433 rv += ',';
00434 }
00435 rv += toPrint[i].toMOF();
00436 }
00437 rv += ')';
00438 }
00439 }
00440 rv += ";\n";
00441 return rv.releaseString();
00442 }
00443
00444 }
00445