//==============================================================================
//
// PLEASE DO NOT EDIT THIS FILE; IT WAS AUTOMATICALLY GENERATED BY GENHND.
//
//==============================================================================

#ifndef _cimple_CIM_LogicalDevice_Hnd
#define _cimple_CIM_LogicalDevice_Hnd

#include <cimple/cimple.h>
#include "CIM_LogicalDevice.h"
#include "CIM_EnabledLogicalElement_Hnd.h"

CIMPLE_NAMESPACE_BEGIN

class CIM_LogicalDevice_Ref : public CIM_EnabledLogicalElement_Ref
{
public:
    typedef CIM_LogicalDevice Class;
    CIM_LogicalDevice_Ref();
    CIM_LogicalDevice_Ref(const CIM_LogicalDevice_Ref& x);
    CIM_LogicalDevice_Ref(CIM_LogicalDevice* inst);
    explicit CIM_LogicalDevice_Ref(const Instance_Ref& x);
    ~CIM_LogicalDevice_Ref();
    CIM_LogicalDevice_Ref& operator=(const CIM_LogicalDevice_Ref& x);
    static bool is_a(const Instance_Ref& x);

    // SystemCreationClassName:
    const String& SystemCreationClassName_value() const;
    void SystemCreationClassName_value(const String& x);
    bool SystemCreationClassName_null() const;
    void SystemCreationClassName_clear();

    // SystemName:
    const String& SystemName_value() const;
    void SystemName_value(const String& x);
    bool SystemName_null() const;
    void SystemName_clear();

    // CreationClassName:
    const String& CreationClassName_value() const;
    void CreationClassName_value(const String& x);
    bool CreationClassName_null() const;
    void CreationClassName_clear();

    // DeviceID:
    const String& DeviceID_value() const;
    void DeviceID_value(const String& x);
    bool DeviceID_null() const;
    void DeviceID_clear();

    Arg<uint32> SetPowerState(
        Ops& __ops,
        const String& __name_space,
        const Arg<uint16>& PowerState,
        const Arg<Datetime>& Time);

    Arg<uint32> Reset(
        Ops& __ops,
        const String& __name_space);

    Arg<uint32> EnableDevice(
        Ops& __ops,
        const String& __name_space,
        const Arg<boolean>& Enabled);

    Arg<uint32> OnlineDevice(
        Ops& __ops,
        const String& __name_space,
        const Arg<boolean>& Online);

    Arg<uint32> QuiesceDevice(
        Ops& __ops,
        const String& __name_space,
        const Arg<boolean>& Quiesce);

    Arg<uint32> SaveProperties(
        Ops& __ops,
        const String& __name_space);

    Arg<uint32> RestoreProperties(
        Ops& __ops,
        const String& __name_space);

protected:
    CIM_LogicalDevice_Ref(const Meta_Class* mc);
    CIM_LogicalDevice_Ref(const Meta_Class* mc, const Instance_Ref& x);
};

class CIM_LogicalDevice_Hnd : public CIM_EnabledLogicalElement_Hnd
{
public:
    typedef CIM_LogicalDevice Class;
    CIM_LogicalDevice_Hnd();
    CIM_LogicalDevice_Hnd(const CIM_LogicalDevice_Hnd& x);
    CIM_LogicalDevice_Hnd(CIM_LogicalDevice* inst);
    explicit CIM_LogicalDevice_Hnd(const Instance_Hnd& x);
    ~CIM_LogicalDevice_Hnd();
    CIM_LogicalDevice_Hnd& operator=(const CIM_LogicalDevice_Hnd& x);
    static bool is_a(const Instance_Hnd& x);
    CIM_LogicalDevice_Ref reference() const;

    // SystemCreationClassName:
    const String& SystemCreationClassName_value() const;
    void SystemCreationClassName_value(const String& x);
    bool SystemCreationClassName_null() const;
    void SystemCreationClassName_clear();

    // SystemName:
    const String& SystemName_value() const;
    void SystemName_value(const String& x);
    bool SystemName_null() const;
    void SystemName_clear();

    // CreationClassName:
    const String& CreationClassName_value() const;
    void CreationClassName_value(const String& x);
    bool CreationClassName_null() const;
    void CreationClassName_clear();

    // DeviceID:
    const String& DeviceID_value() const;
    void DeviceID_value(const String& x);
    bool DeviceID_null() const;
    void DeviceID_clear();

    // PowerManagementSupported:
    const boolean& PowerManagementSupported_value() const;
    void PowerManagementSupported_value(const boolean& x);
    bool PowerManagementSupported_null() const;
    void PowerManagementSupported_clear();

    // PowerManagementCapabilities:
    const Array_uint16& PowerManagementCapabilities_value() const;
    void PowerManagementCapabilities_value(const Array_uint16& x);
    bool PowerManagementCapabilities_null() const;
    void PowerManagementCapabilities_clear();

    // Availability:
    const uint16& Availability_value() const;
    void Availability_value(const uint16& x);
    bool Availability_null() const;
    void Availability_clear();

    // StatusInfo:
    const uint16& StatusInfo_value() const;
    void StatusInfo_value(const uint16& x);
    bool StatusInfo_null() const;
    void StatusInfo_clear();

    // LastErrorCode:
    const uint32& LastErrorCode_value() const;
    void LastErrorCode_value(const uint32& x);
    bool LastErrorCode_null() const;
    void LastErrorCode_clear();

    // ErrorDescription:
    const String& ErrorDescription_value() const;
    void ErrorDescription_value(const String& x);
    bool ErrorDescription_null() const;
    void ErrorDescription_clear();

    // ErrorCleared:
    const boolean& ErrorCleared_value() const;
    void ErrorCleared_value(const boolean& x);
    bool ErrorCleared_null() const;
    void ErrorCleared_clear();

    // OtherIdentifyingInfo:
    const Array_String& OtherIdentifyingInfo_value() const;
    void OtherIdentifyingInfo_value(const Array_String& x);
    bool OtherIdentifyingInfo_null() const;
    void OtherIdentifyingInfo_clear();

    // PowerOnHours:
    const uint64& PowerOnHours_value() const;
    void PowerOnHours_value(const uint64& x);
    bool PowerOnHours_null() const;
    void PowerOnHours_clear();

    // TotalPowerOnHours:
    const uint64& TotalPowerOnHours_value() const;
    void TotalPowerOnHours_value(const uint64& x);
    bool TotalPowerOnHours_null() const;
    void TotalPowerOnHours_clear();

    // IdentifyingDescriptions:
    const Array_String& IdentifyingDescriptions_value() const;
    void IdentifyingDescriptions_value(const Array_String& x);
    bool IdentifyingDescriptions_null() const;
    void IdentifyingDescriptions_clear();

    // AdditionalAvailability:
    const Array_uint16& AdditionalAvailability_value() const;
    void AdditionalAvailability_value(const Array_uint16& x);
    bool AdditionalAvailability_null() const;
    void AdditionalAvailability_clear();

    // MaxQuiesceTime:
    const uint64& MaxQuiesceTime_value() const;
    void MaxQuiesceTime_value(const uint64& x);
    bool MaxQuiesceTime_null() const;
    void MaxQuiesceTime_clear();

protected:
    CIM_LogicalDevice_Hnd(const Meta_Class* mc);
    CIM_LogicalDevice_Hnd(const Meta_Class* mc, const Instance_Hnd& x);
};

inline CIM_LogicalDevice_Ref::CIM_LogicalDevice_Ref() :
    CIM_EnabledLogicalElement_Ref(&CIM_LogicalDevice::static_meta_class)
{
}

inline CIM_LogicalDevice_Ref::CIM_LogicalDevice_Ref(const CIM_LogicalDevice_Ref& x) :
    CIM_EnabledLogicalElement_Ref(x)
{
}

inline CIM_LogicalDevice_Ref::CIM_LogicalDevice_Ref(CIM_LogicalDevice* inst) :
    CIM_EnabledLogicalElement_Ref((CIM_EnabledLogicalElement*)inst)
{
}

inline CIM_LogicalDevice_Ref::CIM_LogicalDevice_Ref(const Instance_Ref& x) : 
    CIM_EnabledLogicalElement_Ref(&CIM_LogicalDevice::static_meta_class, x)
{
}

inline CIM_LogicalDevice_Ref::CIM_LogicalDevice_Ref(const Meta_Class* mc) : CIM_EnabledLogicalElement_Ref(mc)
{
}

inline CIM_LogicalDevice_Ref::CIM_LogicalDevice_Ref(const Meta_Class* mc, const Instance_Ref& x) : CIM_EnabledLogicalElement_Ref(mc, x)
{
}

inline CIM_LogicalDevice_Ref::~CIM_LogicalDevice_Ref()
{
}

inline CIM_LogicalDevice_Ref& CIM_LogicalDevice_Ref::operator=(const CIM_LogicalDevice_Ref& x)
{
    CIM_EnabledLogicalElement_Ref::operator=(x);
    return *this;
}

inline bool CIM_LogicalDevice_Ref::is_a(const Instance_Ref& x)
{
    return is_subclass(&CIM_LogicalDevice::static_meta_class, x.meta_class());
}

inline const String& CIM_LogicalDevice_Ref::SystemCreationClassName_value() const
{
    if (((Class*)_inst)->SystemCreationClassName.null)
        _throw_null_access("SystemCreationClassName");
   return ((Class*)_inst)->SystemCreationClassName.value;
}

inline void CIM_LogicalDevice_Ref::SystemCreationClassName_value(const String& x)
{
    _cow();
   ((Class*)_inst)->SystemCreationClassName.value = x;
   ((Class*)_inst)->SystemCreationClassName.null = false;
}

inline bool CIM_LogicalDevice_Ref::SystemCreationClassName_null() const
{
   return ((Class*)_inst)->SystemCreationClassName.null;
}

inline void CIM_LogicalDevice_Ref::SystemCreationClassName_clear()
{
    _cow();
    __clear(((Class*)_inst)->SystemCreationClassName.value);
    ((Class*)_inst)->SystemCreationClassName.null = true;;
}

inline const String& CIM_LogicalDevice_Ref::SystemName_value() const
{
    if (((Class*)_inst)->SystemName.null)
        _throw_null_access("SystemName");
   return ((Class*)_inst)->SystemName.value;
}

inline void CIM_LogicalDevice_Ref::SystemName_value(const String& x)
{
    _cow();
   ((Class*)_inst)->SystemName.value = x;
   ((Class*)_inst)->SystemName.null = false;
}

inline bool CIM_LogicalDevice_Ref::SystemName_null() const
{
   return ((Class*)_inst)->SystemName.null;
}

inline void CIM_LogicalDevice_Ref::SystemName_clear()
{
    _cow();
    __clear(((Class*)_inst)->SystemName.value);
    ((Class*)_inst)->SystemName.null = true;;
}

inline const String& CIM_LogicalDevice_Ref::CreationClassName_value() const
{
    if (((Class*)_inst)->CreationClassName.null)
        _throw_null_access("CreationClassName");
   return ((Class*)_inst)->CreationClassName.value;
}

inline void CIM_LogicalDevice_Ref::CreationClassName_value(const String& x)
{
    _cow();
   ((Class*)_inst)->CreationClassName.value = x;
   ((Class*)_inst)->CreationClassName.null = false;
}

inline bool CIM_LogicalDevice_Ref::CreationClassName_null() const
{
   return ((Class*)_inst)->CreationClassName.null;
}

inline void CIM_LogicalDevice_Ref::CreationClassName_clear()
{
    _cow();
    __clear(((Class*)_inst)->CreationClassName.value);
    ((Class*)_inst)->CreationClassName.null = true;;
}

inline const String& CIM_LogicalDevice_Ref::DeviceID_value() const
{
    if (((Class*)_inst)->DeviceID.null)
        _throw_null_access("DeviceID");
   return ((Class*)_inst)->DeviceID.value;
}

inline void CIM_LogicalDevice_Ref::DeviceID_value(const String& x)
{
    _cow();
   ((Class*)_inst)->DeviceID.value = x;
   ((Class*)_inst)->DeviceID.null = false;
}

inline bool CIM_LogicalDevice_Ref::DeviceID_null() const
{
   return ((Class*)_inst)->DeviceID.null;
}

inline void CIM_LogicalDevice_Ref::DeviceID_clear()
{
    _cow();
    __clear(((Class*)_inst)->DeviceID.value);
    ((Class*)_inst)->DeviceID.null = true;;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::SetPowerState(
    Ops& __ops,
    const String& __name_space,
    const Arg<uint16>& PowerState,
    const Arg<Datetime>& Time)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_SetPowerState_method::static_meta_class,
        &PowerState,
        &Time,
        &__return_value);
    return __return_value;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::Reset(
    Ops& __ops,
    const String& __name_space)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_Reset_method::static_meta_class,
        &__return_value);
    return __return_value;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::EnableDevice(
    Ops& __ops,
    const String& __name_space,
    const Arg<boolean>& Enabled)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_EnableDevice_method::static_meta_class,
        &Enabled,
        &__return_value);
    return __return_value;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::OnlineDevice(
    Ops& __ops,
    const String& __name_space,
    const Arg<boolean>& Online)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_OnlineDevice_method::static_meta_class,
        &Online,
        &__return_value);
    return __return_value;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::QuiesceDevice(
    Ops& __ops,
    const String& __name_space,
    const Arg<boolean>& Quiesce)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_QuiesceDevice_method::static_meta_class,
        &Quiesce,
        &__return_value);
    return __return_value;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::SaveProperties(
    Ops& __ops,
    const String& __name_space)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_SaveProperties_method::static_meta_class,
        &__return_value);
    return __return_value;
}

inline Arg<uint32> CIM_LogicalDevice_Ref::RestoreProperties(
    Ops& __ops,
    const String& __name_space)
{
    Arg<uint32> __return_value;
    __invoke(
        __ops,
        __name_space,
        *this,
        &CIM_LogicalDevice_RestoreProperties_method::static_meta_class,
        &__return_value);
    return __return_value;
}

inline CIM_LogicalDevice_Hnd::CIM_LogicalDevice_Hnd() :
    CIM_EnabledLogicalElement_Hnd(&CIM_LogicalDevice::static_meta_class)
{
}

inline CIM_LogicalDevice_Hnd::CIM_LogicalDevice_Hnd(const CIM_LogicalDevice_Hnd& x) :
    CIM_EnabledLogicalElement_Hnd(x)
{
}

inline CIM_LogicalDevice_Hnd::CIM_LogicalDevice_Hnd(CIM_LogicalDevice* inst) :
    CIM_EnabledLogicalElement_Hnd((CIM_EnabledLogicalElement*)inst)
{
}

inline CIM_LogicalDevice_Hnd::CIM_LogicalDevice_Hnd(const Instance_Hnd& x) : 
    CIM_EnabledLogicalElement_Hnd(&CIM_LogicalDevice::static_meta_class, x)
{
}

inline CIM_LogicalDevice_Hnd::CIM_LogicalDevice_Hnd(const Meta_Class* mc) : CIM_EnabledLogicalElement_Hnd(mc)
{
}

inline CIM_LogicalDevice_Hnd::CIM_LogicalDevice_Hnd(const Meta_Class* mc, const Instance_Hnd& x) : CIM_EnabledLogicalElement_Hnd(mc, x)
{
}

inline CIM_LogicalDevice_Hnd::~CIM_LogicalDevice_Hnd()
{
}

inline CIM_LogicalDevice_Hnd& CIM_LogicalDevice_Hnd::operator=(const CIM_LogicalDevice_Hnd& x)
{
    CIM_EnabledLogicalElement_Hnd::operator=(x);
    return *this;
}

inline bool CIM_LogicalDevice_Hnd::is_a(const Instance_Hnd& x)
{
    return is_subclass(&CIM_LogicalDevice::static_meta_class, x.meta_class());
}

inline CIM_LogicalDevice_Ref CIM_LogicalDevice_Hnd::reference() const
{
    return CIM_LogicalDevice_Ref((CIM_LogicalDevice*)key_clone(_inst));
}

inline const String& CIM_LogicalDevice_Hnd::SystemCreationClassName_value() const
{
    if (((Class*)_inst)->SystemCreationClassName.null)
        _throw_null_access("SystemCreationClassName");
   return ((Class*)_inst)->SystemCreationClassName.value;
}

inline void CIM_LogicalDevice_Hnd::SystemCreationClassName_value(const String& x)
{
    _cow();
   ((Class*)_inst)->SystemCreationClassName.value = x;
   ((Class*)_inst)->SystemCreationClassName.null = false;
}

inline bool CIM_LogicalDevice_Hnd::SystemCreationClassName_null() const
{
   return ((Class*)_inst)->SystemCreationClassName.null;
}

inline void CIM_LogicalDevice_Hnd::SystemCreationClassName_clear()
{
    _cow();
    __clear(((Class*)_inst)->SystemCreationClassName.value);
    ((Class*)_inst)->SystemCreationClassName.null = true;;
}

inline const String& CIM_LogicalDevice_Hnd::SystemName_value() const
{
    if (((Class*)_inst)->SystemName.null)
        _throw_null_access("SystemName");
   return ((Class*)_inst)->SystemName.value;
}

inline void CIM_LogicalDevice_Hnd::SystemName_value(const String& x)
{
    _cow();
   ((Class*)_inst)->SystemName.value = x;
   ((Class*)_inst)->SystemName.null = false;
}

inline bool CIM_LogicalDevice_Hnd::SystemName_null() const
{
   return ((Class*)_inst)->SystemName.null;
}

inline void CIM_LogicalDevice_Hnd::SystemName_clear()
{
    _cow();
    __clear(((Class*)_inst)->SystemName.value);
    ((Class*)_inst)->SystemName.null = true;;
}

inline const String& CIM_LogicalDevice_Hnd::CreationClassName_value() const
{
    if (((Class*)_inst)->CreationClassName.null)
        _throw_null_access("CreationClassName");
   return ((Class*)_inst)->CreationClassName.value;
}

inline void CIM_LogicalDevice_Hnd::CreationClassName_value(const String& x)
{
    _cow();
   ((Class*)_inst)->CreationClassName.value = x;
   ((Class*)_inst)->CreationClassName.null = false;
}

inline bool CIM_LogicalDevice_Hnd::CreationClassName_null() const
{
   return ((Class*)_inst)->CreationClassName.null;
}

inline void CIM_LogicalDevice_Hnd::CreationClassName_clear()
{
    _cow();
    __clear(((Class*)_inst)->CreationClassName.value);
    ((Class*)_inst)->CreationClassName.null = true;;
}

inline const String& CIM_LogicalDevice_Hnd::DeviceID_value() const
{
    if (((Class*)_inst)->DeviceID.null)
        _throw_null_access("DeviceID");
   return ((Class*)_inst)->DeviceID.value;
}

inline void CIM_LogicalDevice_Hnd::DeviceID_value(const String& x)
{
    _cow();
   ((Class*)_inst)->DeviceID.value = x;
   ((Class*)_inst)->DeviceID.null = false;
}

inline bool CIM_LogicalDevice_Hnd::DeviceID_null() const
{
   return ((Class*)_inst)->DeviceID.null;
}

inline void CIM_LogicalDevice_Hnd::DeviceID_clear()
{
    _cow();
    __clear(((Class*)_inst)->DeviceID.value);
    ((Class*)_inst)->DeviceID.null = true;;
}

inline const boolean& CIM_LogicalDevice_Hnd::PowerManagementSupported_value() const
{
    if (((Class*)_inst)->PowerManagementSupported.null)
        _throw_null_access("PowerManagementSupported");
   return ((Class*)_inst)->PowerManagementSupported.value;
}

inline void CIM_LogicalDevice_Hnd::PowerManagementSupported_value(const boolean& x)
{
    _cow();
   ((Class*)_inst)->PowerManagementSupported.value = x;
   ((Class*)_inst)->PowerManagementSupported.null = false;
}

inline bool CIM_LogicalDevice_Hnd::PowerManagementSupported_null() const
{
   return ((Class*)_inst)->PowerManagementSupported.null;
}

inline void CIM_LogicalDevice_Hnd::PowerManagementSupported_clear()
{
    _cow();
    __clear(((Class*)_inst)->PowerManagementSupported.value);
    ((Class*)_inst)->PowerManagementSupported.null = true;;
}

inline const Array_uint16& CIM_LogicalDevice_Hnd::PowerManagementCapabilities_value() const
{
    if (((Class*)_inst)->PowerManagementCapabilities.null)
        _throw_null_access("PowerManagementCapabilities");
   return ((Class*)_inst)->PowerManagementCapabilities.value;
}

inline void CIM_LogicalDevice_Hnd::PowerManagementCapabilities_value(const Array_uint16& x)
{
    _cow();
   ((Class*)_inst)->PowerManagementCapabilities.value = x;
   ((Class*)_inst)->PowerManagementCapabilities.null = false;
}

inline bool CIM_LogicalDevice_Hnd::PowerManagementCapabilities_null() const
{
   return ((Class*)_inst)->PowerManagementCapabilities.null;
}

inline void CIM_LogicalDevice_Hnd::PowerManagementCapabilities_clear()
{
    _cow();
    __clear(((Class*)_inst)->PowerManagementCapabilities.value);
    ((Class*)_inst)->PowerManagementCapabilities.null = true;;
}

inline const uint16& CIM_LogicalDevice_Hnd::Availability_value() const
{
    if (((Class*)_inst)->Availability.null)
        _throw_null_access("Availability");
   return ((Class*)_inst)->Availability.value;
}

inline void CIM_LogicalDevice_Hnd::Availability_value(const uint16& x)
{
    _cow();
   ((Class*)_inst)->Availability.value = x;
   ((Class*)_inst)->Availability.null = false;
}

inline bool CIM_LogicalDevice_Hnd::Availability_null() const
{
   return ((Class*)_inst)->Availability.null;
}

inline void CIM_LogicalDevice_Hnd::Availability_clear()
{
    _cow();
    __clear(((Class*)_inst)->Availability.value);
    ((Class*)_inst)->Availability.null = true;;
}

inline const uint16& CIM_LogicalDevice_Hnd::StatusInfo_value() const
{
    if (((Class*)_inst)->StatusInfo.null)
        _throw_null_access("StatusInfo");
   return ((Class*)_inst)->StatusInfo.value;
}

inline void CIM_LogicalDevice_Hnd::StatusInfo_value(const uint16& x)
{
    _cow();
   ((Class*)_inst)->StatusInfo.value = x;
   ((Class*)_inst)->StatusInfo.null = false;
}

inline bool CIM_LogicalDevice_Hnd::StatusInfo_null() const
{
   return ((Class*)_inst)->StatusInfo.null;
}

inline void CIM_LogicalDevice_Hnd::StatusInfo_clear()
{
    _cow();
    __clear(((Class*)_inst)->StatusInfo.value);
    ((Class*)_inst)->StatusInfo.null = true;;
}

inline const uint32& CIM_LogicalDevice_Hnd::LastErrorCode_value() const
{
    if (((Class*)_inst)->LastErrorCode.null)
        _throw_null_access("LastErrorCode");
   return ((Class*)_inst)->LastErrorCode.value;
}

inline void CIM_LogicalDevice_Hnd::LastErrorCode_value(const uint32& x)
{
    _cow();
   ((Class*)_inst)->LastErrorCode.value = x;
   ((Class*)_inst)->LastErrorCode.null = false;
}

inline bool CIM_LogicalDevice_Hnd::LastErrorCode_null() const
{
   return ((Class*)_inst)->LastErrorCode.null;
}

inline void CIM_LogicalDevice_Hnd::LastErrorCode_clear()
{
    _cow();
    __clear(((Class*)_inst)->LastErrorCode.value);
    ((Class*)_inst)->LastErrorCode.null = true;;
}

inline const String& CIM_LogicalDevice_Hnd::ErrorDescription_value() const
{
    if (((Class*)_inst)->ErrorDescription.null)
        _throw_null_access("ErrorDescription");
   return ((Class*)_inst)->ErrorDescription.value;
}

inline void CIM_LogicalDevice_Hnd::ErrorDescription_value(const String& x)
{
    _cow();
   ((Class*)_inst)->ErrorDescription.value = x;
   ((Class*)_inst)->ErrorDescription.null = false;
}

inline bool CIM_LogicalDevice_Hnd::ErrorDescription_null() const
{
   return ((Class*)_inst)->ErrorDescription.null;
}

inline void CIM_LogicalDevice_Hnd::ErrorDescription_clear()
{
    _cow();
    __clear(((Class*)_inst)->ErrorDescription.value);
    ((Class*)_inst)->ErrorDescription.null = true;;
}

inline const boolean& CIM_LogicalDevice_Hnd::ErrorCleared_value() const
{
    if (((Class*)_inst)->ErrorCleared.null)
        _throw_null_access("ErrorCleared");
   return ((Class*)_inst)->ErrorCleared.value;
}

inline void CIM_LogicalDevice_Hnd::ErrorCleared_value(const boolean& x)
{
    _cow();
   ((Class*)_inst)->ErrorCleared.value = x;
   ((Class*)_inst)->ErrorCleared.null = false;
}

inline bool CIM_LogicalDevice_Hnd::ErrorCleared_null() const
{
   return ((Class*)_inst)->ErrorCleared.null;
}

inline void CIM_LogicalDevice_Hnd::ErrorCleared_clear()
{
    _cow();
    __clear(((Class*)_inst)->ErrorCleared.value);
    ((Class*)_inst)->ErrorCleared.null = true;;
}

inline const Array_String& CIM_LogicalDevice_Hnd::OtherIdentifyingInfo_value() const
{
    if (((Class*)_inst)->OtherIdentifyingInfo.null)
        _throw_null_access("OtherIdentifyingInfo");
   return ((Class*)_inst)->OtherIdentifyingInfo.value;
}

inline void CIM_LogicalDevice_Hnd::OtherIdentifyingInfo_value(const Array_String& x)
{
    _cow();
   ((Class*)_inst)->OtherIdentifyingInfo.value = x;
   ((Class*)_inst)->OtherIdentifyingInfo.null = false;
}

inline bool CIM_LogicalDevice_Hnd::OtherIdentifyingInfo_null() const
{
   return ((Class*)_inst)->OtherIdentifyingInfo.null;
}

inline void CIM_LogicalDevice_Hnd::OtherIdentifyingInfo_clear()
{
    _cow();
    __clear(((Class*)_inst)->OtherIdentifyingInfo.value);
    ((Class*)_inst)->OtherIdentifyingInfo.null = true;;
}

inline const uint64& CIM_LogicalDevice_Hnd::PowerOnHours_value() const
{
    if (((Class*)_inst)->PowerOnHours.null)
        _throw_null_access("PowerOnHours");
   return ((Class*)_inst)->PowerOnHours.value;
}

inline void CIM_LogicalDevice_Hnd::PowerOnHours_value(const uint64& x)
{
    _cow();
   ((Class*)_inst)->PowerOnHours.value = x;
   ((Class*)_inst)->PowerOnHours.null = false;
}

inline bool CIM_LogicalDevice_Hnd::PowerOnHours_null() const
{
   return ((Class*)_inst)->PowerOnHours.null;
}

inline void CIM_LogicalDevice_Hnd::PowerOnHours_clear()
{
    _cow();
    __clear(((Class*)_inst)->PowerOnHours.value);
    ((Class*)_inst)->PowerOnHours.null = true;;
}

inline const uint64& CIM_LogicalDevice_Hnd::TotalPowerOnHours_value() const
{
    if (((Class*)_inst)->TotalPowerOnHours.null)
        _throw_null_access("TotalPowerOnHours");
   return ((Class*)_inst)->TotalPowerOnHours.value;
}

inline void CIM_LogicalDevice_Hnd::TotalPowerOnHours_value(const uint64& x)
{
    _cow();
   ((Class*)_inst)->TotalPowerOnHours.value = x;
   ((Class*)_inst)->TotalPowerOnHours.null = false;
}

inline bool CIM_LogicalDevice_Hnd::TotalPowerOnHours_null() const
{
   return ((Class*)_inst)->TotalPowerOnHours.null;
}

inline void CIM_LogicalDevice_Hnd::TotalPowerOnHours_clear()
{
    _cow();
    __clear(((Class*)_inst)->TotalPowerOnHours.value);
    ((Class*)_inst)->TotalPowerOnHours.null = true;;
}

inline const Array_String& CIM_LogicalDevice_Hnd::IdentifyingDescriptions_value() const
{
    if (((Class*)_inst)->IdentifyingDescriptions.null)
        _throw_null_access("IdentifyingDescriptions");
   return ((Class*)_inst)->IdentifyingDescriptions.value;
}

inline void CIM_LogicalDevice_Hnd::IdentifyingDescriptions_value(const Array_String& x)
{
    _cow();
   ((Class*)_inst)->IdentifyingDescriptions.value = x;
   ((Class*)_inst)->IdentifyingDescriptions.null = false;
}

inline bool CIM_LogicalDevice_Hnd::IdentifyingDescriptions_null() const
{
   return ((Class*)_inst)->IdentifyingDescriptions.null;
}

inline void CIM_LogicalDevice_Hnd::IdentifyingDescriptions_clear()
{
    _cow();
    __clear(((Class*)_inst)->IdentifyingDescriptions.value);
    ((Class*)_inst)->IdentifyingDescriptions.null = true;;
}

inline const Array_uint16& CIM_LogicalDevice_Hnd::AdditionalAvailability_value() const
{
    if (((Class*)_inst)->AdditionalAvailability.null)
        _throw_null_access("AdditionalAvailability");
   return ((Class*)_inst)->AdditionalAvailability.value;
}

inline void CIM_LogicalDevice_Hnd::AdditionalAvailability_value(const Array_uint16& x)
{
    _cow();
   ((Class*)_inst)->AdditionalAvailability.value = x;
   ((Class*)_inst)->AdditionalAvailability.null = false;
}

inline bool CIM_LogicalDevice_Hnd::AdditionalAvailability_null() const
{
   return ((Class*)_inst)->AdditionalAvailability.null;
}

inline void CIM_LogicalDevice_Hnd::AdditionalAvailability_clear()
{
    _cow();
    __clear(((Class*)_inst)->AdditionalAvailability.value);
    ((Class*)_inst)->AdditionalAvailability.null = true;;
}

inline const uint64& CIM_LogicalDevice_Hnd::MaxQuiesceTime_value() const
{
    if (((Class*)_inst)->MaxQuiesceTime.null)
        _throw_null_access("MaxQuiesceTime");
   return ((Class*)_inst)->MaxQuiesceTime.value;
}

inline void CIM_LogicalDevice_Hnd::MaxQuiesceTime_value(const uint64& x)
{
    _cow();
   ((Class*)_inst)->MaxQuiesceTime.value = x;
   ((Class*)_inst)->MaxQuiesceTime.null = false;
}

inline bool CIM_LogicalDevice_Hnd::MaxQuiesceTime_null() const
{
   return ((Class*)_inst)->MaxQuiesceTime.null;
}

inline void CIM_LogicalDevice_Hnd::MaxQuiesceTime_clear()
{
    _cow();
    __clear(((Class*)_inst)->MaxQuiesceTime.value);
    ((Class*)_inst)->MaxQuiesceTime.null = true;;
}

CIMPLE_NAMESPACE_END

#endif /* _cimple_CIM_LogicalDevice_Hnd_h */