text:
using namespace OpenHome;
using namespace OpenHome::Net;

class CpProxyUpnpOrgDimming1C : public CpProxyC
{
public:
    CpProxyUpnpOrgDimming1C(CpDeviceC aDevice);
    ~CpProxyUpnpOrgDimming1C();
    //CpProxyUpnpOrgDimming1* Proxy() { return static_cast<CpProxyUpnpOrgDimming1*>(iProxy); }

    void SyncSetLoadLevelTarget(TUint anewLoadlevelTarget);
    void BeginSetLoadLevelTarget(TUint anewLoadlevelTarget, FunctorAsync& aFunctor);
    void EndSetLoadLevelTarget(IAsync& aAsync);

    void SyncGetLoadLevelTarget(TUint& aGetLoadlevelTarget);
    void BeginGetLoadLevelTarget(FunctorAsync& aFunctor);
    void EndGetLoadLevelTarget(IAsync& aAsync, TUint& aGetLoadlevelTarget);

    void SyncGetLoadLevelStatus(TUint& aretLoadlevelStatus);
    void BeginGetLoadLevelStatus(FunctorAsync& aFunctor);
    void EndGetLoadLevelStatus(IAsync& aAsync, TUint& aretLoadlevelStatus);

    void SyncSetOnEffectLevel(TUint anewOnEffectLevel);
    void BeginSetOnEffectLevel(TUint anewOnEffectLevel, FunctorAsync& aFunctor);
    void EndSetOnEffectLevel(IAsync& aAsync);

    void SyncSetOnEffect(const Brx& anewOnEffect);
    void BeginSetOnEffect(const Brx& anewOnEffect, FunctorAsync& aFunctor);
    void EndSetOnEffect(IAsync& aAsync);

    void SyncGetOnEffectParameters(Brh& aretOnEffect, TUint& aretOnEffectLevel);
    void BeginGetOnEffectParameters(FunctorAsync& aFunctor);
    void EndGetOnEffectParameters(IAsync& aAsync, Brh& aretOnEffect, TUint& aretOnEffectLevel);

    void SyncStepUp();
    void BeginStepUp(FunctorAsync& aFunctor);
    void EndStepUp(IAsync& aAsync);

    void SyncStepDown();
    void BeginStepDown(FunctorAsync& aFunctor);
    void EndStepDown(IAsync& aAsync);

    void SyncStartRampUp();
    void BeginStartRampUp(FunctorAsync& aFunctor);
    void EndStartRampUp(IAsync& aAsync);

    void SyncStartRampDown();
    void BeginStartRampDown(FunctorAsync& aFunctor);
    void EndStartRampDown(IAsync& aAsync);

    void SyncStopRamp();
    void BeginStopRamp(FunctorAsync& aFunctor);
    void EndStopRamp(IAsync& aAsync);

    void SyncStartRampToLevel(TUint anewLoadLevelTarget, TUint anewRampTime);
    void BeginStartRampToLevel(TUint anewLoadLevelTarget, TUint anewRampTime, FunctorAsync& aFunctor);
    void EndStartRampToLevel(IAsync& aAsync);

    void SyncSetStepDelta(TUint anewStepDelta);
    void BeginSetStepDelta(TUint anewStepDelta, FunctorAsync& aFunctor);
    void EndSetStepDelta(IAsync& aAsync);

    void SyncGetStepDelta(TUint& aretStepDelta);
    void BeginGetStepDelta(FunctorAsync& aFunctor);
    void EndGetStepDelta(IAsync& aAsync, TUint& aretStepDelta);

    void SyncSetRampRate(TUint anewRampRate);
    void BeginSetRampRate(TUint anewRampRate, FunctorAsync& aFunctor);
    void EndSetRampRate(IAsync& aAsync);

    void SyncGetRampRate(TUint& aretRampRate);
    void BeginGetRampRate(FunctorAsync& aFunctor);
    void EndGetRampRate(IAsync& aAsync, TUint& aretRampRate);

    void SyncPauseRamp();
    void BeginPauseRamp(FunctorAsync& aFunctor);
    void EndPauseRamp(IAsync& aAsync);

    void SyncResumeRamp();
    void BeginResumeRamp(FunctorAsync& aFunctor);
    void EndResumeRamp(IAsync& aAsync);

    void SyncGetIsRamping(TBool& aretIsRamping);
    void BeginGetIsRamping(FunctorAsync& aFunctor);
    void EndGetIsRamping(IAsync& aAsync, TBool& aretIsRamping);

    void SyncGetRampPaused(TBool& aretRampPaused);
    void BeginGetRampPaused(FunctorAsync& aFunctor);
    void EndGetRampPaused(IAsync& aAsync, TBool& aretRampPaused);

    void SyncGetRampTime(TUint& aretRampTime);
    void BeginGetRampTime(FunctorAsync& aFunctor);
    void EndGetRampTime(IAsync& aAsync, TUint& aretRampTime);

    void SetPropertyLoadLevelStatusChanged(Functor& aFunctor);
    void SetPropertyStepDeltaChanged(Functor& aFunctor);
    void SetPropertyRampRateChanged(Functor& aFunctor);
    void SetPropertyIsRampingChanged(Functor& aFunctor);
    void SetPropertyRampPausedChanged(Functor& aFunctor);

    void PropertyLoadLevelStatus(TUint& aLoadLevelStatus) const;
    void PropertyStepDelta(TUint& aStepDelta) const;
    void PropertyRampRate(TUint& aRampRate) const;
    void PropertyIsRamping(TBool& aIsRamping) const;
    void PropertyRampPaused(TBool& aRampPaused) const;
private:
    void LoadLevelStatusPropertyChanged();
    void StepDeltaPropertyChanged();
    void RampRatePropertyChanged();
    void IsRampingPropertyChanged();
    void RampPausedPropertyChanged();
private:
    Mutex iLock;
    Action* iActionSetLoadLevelTarget;
    Action* iActionGetLoadLevelTarget;
    Action* iActionGetLoadLevelStatus;
    Action* iActionSetOnEffectLevel;
    Action* iActionSetOnEffect;
    Action* iActionGetOnEffectParameters;
    Action* iActionStepUp;
    Action* iActionStepDown;
    Action* iActionStartRampUp;
    Action* iActionStartRampDown;
    Action* iActionStopRamp;
    Action* iActionStartRampToLevel;
    Action* iActionSetStepDelta;
    Action* iActionGetStepDelta;
    Action* iActionSetRampRate;
    Action* iActionGetRampRate;
    Action* iActionPauseRamp;
    Action* iActionResumeRamp;
    Action* iActionGetIsRamping;
    Action* iActionGetRampPaused;
    Action* iActionGetRampTime;
    PropertyUint* iLoadLevelStatus;
    PropertyUint* iStepDelta;
    PropertyUint* iRampRate;
    PropertyBool* iIsRamping;
    PropertyBool* iRampPaused;
    Functor iLoadLevelStatusChanged;
    Functor iStepDeltaChanged;
    Functor iRampRateChanged;
    Functor iIsRampingChanged;
    Functor iRampPausedChanged;
};

class SyncSetLoadLevelTargetUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncSetLoadLevelTargetUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncSetLoadLevelTargetUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncSetLoadLevelTargetUpnpOrgDimming1C::SyncSetLoadLevelTargetUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncSetLoadLevelTargetUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndSetLoadLevelTarget(aAsync);
}

class SyncGetLoadLevelTargetUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetLoadLevelTargetUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aGetLoadlevelTarget);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetLoadLevelTargetUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TUint& iGetLoadlevelTarget;
};

SyncGetLoadLevelTargetUpnpOrgDimming1C::SyncGetLoadLevelTargetUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aGetLoadlevelTarget)
    : iService(aProxy)
    , iGetLoadlevelTarget(aGetLoadlevelTarget)
{
}

void SyncGetLoadLevelTargetUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetLoadLevelTarget(aAsync, iGetLoadlevelTarget);
}

class SyncGetLoadLevelStatusUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetLoadLevelStatusUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretLoadlevelStatus);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetLoadLevelStatusUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TUint& iretLoadlevelStatus;
};

SyncGetLoadLevelStatusUpnpOrgDimming1C::SyncGetLoadLevelStatusUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretLoadlevelStatus)
    : iService(aProxy)
    , iretLoadlevelStatus(aretLoadlevelStatus)
{
}

void SyncGetLoadLevelStatusUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetLoadLevelStatus(aAsync, iretLoadlevelStatus);
}

class SyncSetOnEffectLevelUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncSetOnEffectLevelUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncSetOnEffectLevelUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncSetOnEffectLevelUpnpOrgDimming1C::SyncSetOnEffectLevelUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncSetOnEffectLevelUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndSetOnEffectLevel(aAsync);
}

class SyncSetOnEffectUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncSetOnEffectUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncSetOnEffectUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncSetOnEffectUpnpOrgDimming1C::SyncSetOnEffectUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncSetOnEffectUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndSetOnEffect(aAsync);
}

class SyncGetOnEffectParametersUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetOnEffectParametersUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, Brh& aretOnEffect, TUint& aretOnEffectLevel);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetOnEffectParametersUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    Brh& iretOnEffect;
    TUint& iretOnEffectLevel;
};

SyncGetOnEffectParametersUpnpOrgDimming1C::SyncGetOnEffectParametersUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, Brh& aretOnEffect, TUint& aretOnEffectLevel)
    : iService(aProxy)
    , iretOnEffect(aretOnEffect)
    , iretOnEffectLevel(aretOnEffectLevel)
{
}

void SyncGetOnEffectParametersUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetOnEffectParameters(aAsync, iretOnEffect, iretOnEffectLevel);
}

class SyncStepUpUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncStepUpUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncStepUpUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncStepUpUpnpOrgDimming1C::SyncStepUpUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncStepUpUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndStepUp(aAsync);
}

class SyncStepDownUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncStepDownUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncStepDownUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncStepDownUpnpOrgDimming1C::SyncStepDownUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncStepDownUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndStepDown(aAsync);
}

class SyncStartRampUpUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncStartRampUpUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncStartRampUpUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncStartRampUpUpnpOrgDimming1C::SyncStartRampUpUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncStartRampUpUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndStartRampUp(aAsync);
}

class SyncStartRampDownUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncStartRampDownUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncStartRampDownUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncStartRampDownUpnpOrgDimming1C::SyncStartRampDownUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncStartRampDownUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndStartRampDown(aAsync);
}

class SyncStopRampUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncStopRampUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncStopRampUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncStopRampUpnpOrgDimming1C::SyncStopRampUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncStopRampUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndStopRamp(aAsync);
}

class SyncStartRampToLevelUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncStartRampToLevelUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncStartRampToLevelUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncStartRampToLevelUpnpOrgDimming1C::SyncStartRampToLevelUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncStartRampToLevelUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndStartRampToLevel(aAsync);
}

class SyncSetStepDeltaUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncSetStepDeltaUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncSetStepDeltaUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncSetStepDeltaUpnpOrgDimming1C::SyncSetStepDeltaUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncSetStepDeltaUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndSetStepDelta(aAsync);
}

class SyncGetStepDeltaUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetStepDeltaUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretStepDelta);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetStepDeltaUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TUint& iretStepDelta;
};

SyncGetStepDeltaUpnpOrgDimming1C::SyncGetStepDeltaUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretStepDelta)
    : iService(aProxy)
    , iretStepDelta(aretStepDelta)
{
}

void SyncGetStepDeltaUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetStepDelta(aAsync, iretStepDelta);
}

class SyncSetRampRateUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncSetRampRateUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncSetRampRateUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncSetRampRateUpnpOrgDimming1C::SyncSetRampRateUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncSetRampRateUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndSetRampRate(aAsync);
}

class SyncGetRampRateUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetRampRateUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretRampRate);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetRampRateUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TUint& iretRampRate;
};

SyncGetRampRateUpnpOrgDimming1C::SyncGetRampRateUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretRampRate)
    : iService(aProxy)
    , iretRampRate(aretRampRate)
{
}

void SyncGetRampRateUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetRampRate(aAsync, iretRampRate);
}

class SyncPauseRampUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncPauseRampUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncPauseRampUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncPauseRampUpnpOrgDimming1C::SyncPauseRampUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncPauseRampUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndPauseRamp(aAsync);
}

class SyncResumeRampUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncResumeRampUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncResumeRampUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
};

SyncResumeRampUpnpOrgDimming1C::SyncResumeRampUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy)
    : iService(aProxy)
{
}

void SyncResumeRampUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndResumeRamp(aAsync);
}

class SyncGetIsRampingUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetIsRampingUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TBool& aretIsRamping);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetIsRampingUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TBool& iretIsRamping;
};

SyncGetIsRampingUpnpOrgDimming1C::SyncGetIsRampingUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TBool& aretIsRamping)
    : iService(aProxy)
    , iretIsRamping(aretIsRamping)
{
}

void SyncGetIsRampingUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetIsRamping(aAsync, iretIsRamping);
}

class SyncGetRampPausedUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetRampPausedUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TBool& aretRampPaused);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetRampPausedUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TBool& iretRampPaused;
};

SyncGetRampPausedUpnpOrgDimming1C::SyncGetRampPausedUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TBool& aretRampPaused)
    : iService(aProxy)
    , iretRampPaused(aretRampPaused)
{
}

void SyncGetRampPausedUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetRampPaused(aAsync, iretRampPaused);
}

class SyncGetRampTimeUpnpOrgDimming1C : public SyncProxyAction
{
public:
    SyncGetRampTimeUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretRampTime);
    virtual void CompleteRequest(IAsync& aAsync);
    virtual ~SyncGetRampTimeUpnpOrgDimming1C() {};
private:
    CpProxyUpnpOrgDimming1C& iService;
    TUint& iretRampTime;
};

SyncGetRampTimeUpnpOrgDimming1C::SyncGetRampTimeUpnpOrgDimming1C(CpProxyUpnpOrgDimming1C& aProxy, TUint& aretRampTime)
    : iService(aProxy)
    , iretRampTime(aretRampTime)
{
}

void SyncGetRampTimeUpnpOrgDimming1C::CompleteRequest(IAsync& aAsync)
{
    iService.EndGetRampTime(aAsync, iretRampTime);
}

CpProxyUpnpOrgDimming1C::CpProxyUpnpOrgDimming1C(CpDeviceC aDevice)
    : CpProxyC("schemas-upnp-org", "Dimming", 1, *reinterpret_cast<CpiDevice*>(aDevice))
    , iLock("MPCS")
{
    OpenHome::Net::Parameter* param;
    TChar** allowedValues;
    TUint index;

    iActionSetLoadLevelTarget = new Action("SetLoadLevelTarget");
    param = new OpenHome::Net::ParameterUint("newLoadlevelTarget", 0, 100);
    iActionSetLoadLevelTarget->AddInputParameter(param);

    iActionGetLoadLevelTarget = new Action("GetLoadLevelTarget");
    param = new OpenHome::Net::ParameterUint("GetLoadlevelTarget", 0, 100);
    iActionGetLoadLevelTarget->AddOutputParameter(param);

    iActionGetLoadLevelStatus = new Action("GetLoadLevelStatus");
    param = new OpenHome::Net::ParameterUint("retLoadlevelStatus", 0, 100);
    iActionGetLoadLevelStatus->AddOutputParameter(param);

    iActionSetOnEffectLevel = new Action("SetOnEffectLevel");
    param = new OpenHome::Net::ParameterUint("newOnEffectLevel", 0, 100);
    iActionSetOnEffectLevel->AddInputParameter(param);

    iActionSetOnEffect = new Action("SetOnEffect");
    index = 0;
    allowedValues = new TChar*[3];
    allowedValues[index++] = (TChar*)"OnEffectLevel";
    allowedValues[index++] = (TChar*)"LastSetting";
    allowedValues[index++] = (TChar*)"Default";
    param = new OpenHome::Net::ParameterString("newOnEffect", allowedValues, 3);
    iActionSetOnEffect->AddInputParameter(param);
    delete[] allowedValues;

    iActionGetOnEffectParameters = new Action("GetOnEffectParameters");
    index = 0;
    allowedValues = new TChar*[3];
    allowedValues[index++] = (TChar*)"OnEffectLevel";
    allowedValues[index++] = (TChar*)"LastSetting";
    allowedValues[index++] = (TChar*)"Default";
    param = new OpenHome::Net::ParameterString("retOnEffect", allowedValues, 3);
    iActionGetOnEffectParameters->AddOutputParameter(param);
    delete[] allowedValues;
    param = new OpenHome::Net::ParameterUint("retOnEffectLevel", 0, 100);
    iActionGetOnEffectParameters->AddOutputParameter(param);

    iActionStepUp = new Action("StepUp");

    iActionStepDown = new Action("StepDown");

    iActionStartRampUp = new Action("StartRampUp");

    iActionStartRampDown = new Action("StartRampDown");

    iActionStopRamp = new Action("StopRamp");

    iActionStartRampToLevel = new Action("StartRampToLevel");
    param = new OpenHome::Net::ParameterUint("newLoadLevelTarget", 0, 100);
    iActionStartRampToLevel->AddInputParameter(param);
    param = new OpenHome::Net::ParameterUint("newRampTime");
    iActionStartRampToLevel->AddInputParameter(param);

    iActionSetStepDelta = new Action("SetStepDelta");
    param = new OpenHome::Net::ParameterUint("newStepDelta", 1, 100);
    iActionSetStepDelta->AddInputParameter(param);

    iActionGetStepDelta = new Action("GetStepDelta");
    param = new OpenHome::Net::ParameterUint("retStepDelta", 1, 100);
    iActionGetStepDelta->AddOutputParameter(param);

    iActionSetRampRate = new Action("SetRampRate");
    param = new OpenHome::Net::ParameterUint("newRampRate", 0, 100);
    iActionSetRampRate->AddInputParameter(param);

    iActionGetRampRate = new Action("GetRampRate");
    param = new OpenHome::Net::ParameterUint("retRampRate", 0, 100);
    iActionGetRampRate->AddOutputParameter(param);

    iActionPauseRamp = new Action("PauseRamp");

    iActionResumeRamp = new Action("ResumeRamp");

    iActionGetIsRamping = new Action("GetIsRamping");
    param = new OpenHome::Net::ParameterBool("retIsRamping");
    iActionGetIsRamping->AddOutputParameter(param);

    iActionGetRampPaused = new Action("GetRampPaused");
    param = new OpenHome::Net::ParameterBool("retRampPaused");
    iActionGetRampPaused->AddOutputParameter(param);

    iActionGetRampTime = new Action("GetRampTime");
    param = new OpenHome::Net::ParameterUint("retRampTime");
    iActionGetRampTime->AddOutputParameter(param);

    Functor functor;
    functor = MakeFunctor(*this, &CpProxyUpnpOrgDimming1C::LoadLevelStatusPropertyChanged);
    iLoadLevelStatus = new PropertyUint("LoadLevelStatus", functor);
    AddProperty(iLoadLevelStatus);
    functor = MakeFunctor(*this, &CpProxyUpnpOrgDimming1C::StepDeltaPropertyChanged);
    iStepDelta = new PropertyUint("StepDelta", functor);
    AddProperty(iStepDelta);
    functor = MakeFunctor(*this, &CpProxyUpnpOrgDimming1C::RampRatePropertyChanged);
    iRampRate = new PropertyUint("RampRate", functor);
    AddProperty(iRampRate);
    functor = MakeFunctor(*this, &CpProxyUpnpOrgDimming1C::IsRampingPropertyChanged);
    iIsRamping = new PropertyBool("IsRamping", functor);
    AddProperty(iIsRamping);
    functor = MakeFunctor(*this, &CpProxyUpnpOrgDimming1C::RampPausedPropertyChanged);
    iRampPaused = new PropertyBool("RampPaused", functor);
    AddProperty(iRampPaused);
}

CpProxyUpnpOrgDimming1C::~CpProxyUpnpOrgDimming1C()
{
    DestroyService();
    delete iActionSetLoadLevelTarget;
    delete iActionGetLoadLevelTarget;
    delete iActionGetLoadLevelStatus;
    delete iActionSetOnEffectLevel;
    delete iActionSetOnEffect;
    delete iActionGetOnEffectParameters;
    delete iActionStepUp;
    delete iActionStepDown;
    delete iActionStartRampUp;
    delete iActionStartRampDown;
    delete iActionStopRamp;
    delete iActionStartRampToLevel;
    delete iActionSetStepDelta;
    delete iActionGetStepDelta;
    delete iActionSetRampRate;
    delete iActionGetRampRate;
    delete iActionPauseRamp;
    delete iActionResumeRamp;
    delete iActionGetIsRamping;
    delete iActionGetRampPaused;
    delete iActionGetRampTime;
}

void CpProxyUpnpOrgDimming1C::SyncSetLoadLevelTarget(TUint anewLoadlevelTarget)
{
    SyncSetLoadLevelTargetUpnpOrgDimming1C sync(*this);
    BeginSetLoadLevelTarget(anewLoadlevelTarget, sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginSetLoadLevelTarget(TUint anewLoadlevelTarget, FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionSetLoadLevelTarget, aFunctor);
    TUint inIndex = 0;
    const Action::VectorParameters& inParams = iActionSetLoadLevelTarget->InputParameters();
    invocation->AddInput(new ArgumentUint(*inParams[inIndex++], anewLoadlevelTarget));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndSetLoadLevelTarget(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("SetLoadLevelTarget"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncGetLoadLevelTarget(TUint& aGetLoadlevelTarget)
{
    SyncGetLoadLevelTargetUpnpOrgDimming1C sync(*this, aGetLoadlevelTarget);
    BeginGetLoadLevelTarget(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetLoadLevelTarget(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetLoadLevelTarget, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetLoadLevelTarget->OutputParameters();
    invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetLoadLevelTarget(IAsync& aAsync, TUint& aGetLoadlevelTarget)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetLoadLevelTarget"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aGetLoadlevelTarget = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncGetLoadLevelStatus(TUint& aretLoadlevelStatus)
{
    SyncGetLoadLevelStatusUpnpOrgDimming1C sync(*this, aretLoadlevelStatus);
    BeginGetLoadLevelStatus(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetLoadLevelStatus(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetLoadLevelStatus, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetLoadLevelStatus->OutputParameters();
    invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetLoadLevelStatus(IAsync& aAsync, TUint& aretLoadlevelStatus)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetLoadLevelStatus"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aretLoadlevelStatus = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncSetOnEffectLevel(TUint anewOnEffectLevel)
{
    SyncSetOnEffectLevelUpnpOrgDimming1C sync(*this);
    BeginSetOnEffectLevel(anewOnEffectLevel, sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginSetOnEffectLevel(TUint anewOnEffectLevel, FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionSetOnEffectLevel, aFunctor);
    TUint inIndex = 0;
    const Action::VectorParameters& inParams = iActionSetOnEffectLevel->InputParameters();
    invocation->AddInput(new ArgumentUint(*inParams[inIndex++], anewOnEffectLevel));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndSetOnEffectLevel(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("SetOnEffectLevel"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncSetOnEffect(const Brx& anewOnEffect)
{
    SyncSetOnEffectUpnpOrgDimming1C sync(*this);
    BeginSetOnEffect(anewOnEffect, sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginSetOnEffect(const Brx& anewOnEffect, FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionSetOnEffect, aFunctor);
    TUint inIndex = 0;
    const Action::VectorParameters& inParams = iActionSetOnEffect->InputParameters();
    invocation->AddInput(new ArgumentString(*inParams[inIndex++], anewOnEffect));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndSetOnEffect(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("SetOnEffect"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncGetOnEffectParameters(Brh& aretOnEffect, TUint& aretOnEffectLevel)
{
    SyncGetOnEffectParametersUpnpOrgDimming1C sync(*this, aretOnEffect, aretOnEffectLevel);
    BeginGetOnEffectParameters(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetOnEffectParameters(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetOnEffectParameters, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetOnEffectParameters->OutputParameters();
    invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
    invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetOnEffectParameters(IAsync& aAsync, Brh& aretOnEffect, TUint& aretOnEffectLevel)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetOnEffectParameters"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aretOnEffect);
    aretOnEffectLevel = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncStepUp()
{
    SyncStepUpUpnpOrgDimming1C sync(*this);
    BeginStepUp(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginStepUp(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionStepUp, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndStepUp(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("StepUp"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncStepDown()
{
    SyncStepDownUpnpOrgDimming1C sync(*this);
    BeginStepDown(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginStepDown(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionStepDown, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndStepDown(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("StepDown"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncStartRampUp()
{
    SyncStartRampUpUpnpOrgDimming1C sync(*this);
    BeginStartRampUp(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginStartRampUp(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionStartRampUp, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndStartRampUp(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("StartRampUp"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncStartRampDown()
{
    SyncStartRampDownUpnpOrgDimming1C sync(*this);
    BeginStartRampDown(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginStartRampDown(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionStartRampDown, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndStartRampDown(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("StartRampDown"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncStopRamp()
{
    SyncStopRampUpnpOrgDimming1C sync(*this);
    BeginStopRamp(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginStopRamp(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionStopRamp, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndStopRamp(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("StopRamp"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncStartRampToLevel(TUint anewLoadLevelTarget, TUint anewRampTime)
{
    SyncStartRampToLevelUpnpOrgDimming1C sync(*this);
    BeginStartRampToLevel(anewLoadLevelTarget, anewRampTime, sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginStartRampToLevel(TUint anewLoadLevelTarget, TUint anewRampTime, FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionStartRampToLevel, aFunctor);
    TUint inIndex = 0;
    const Action::VectorParameters& inParams = iActionStartRampToLevel->InputParameters();
    invocation->AddInput(new ArgumentUint(*inParams[inIndex++], anewLoadLevelTarget));
    invocation->AddInput(new ArgumentUint(*inParams[inIndex++], anewRampTime));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndStartRampToLevel(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("StartRampToLevel"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncSetStepDelta(TUint anewStepDelta)
{
    SyncSetStepDeltaUpnpOrgDimming1C sync(*this);
    BeginSetStepDelta(anewStepDelta, sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginSetStepDelta(TUint anewStepDelta, FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionSetStepDelta, aFunctor);
    TUint inIndex = 0;
    const Action::VectorParameters& inParams = iActionSetStepDelta->InputParameters();
    invocation->AddInput(new ArgumentUint(*inParams[inIndex++], anewStepDelta));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndSetStepDelta(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("SetStepDelta"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncGetStepDelta(TUint& aretStepDelta)
{
    SyncGetStepDeltaUpnpOrgDimming1C sync(*this, aretStepDelta);
    BeginGetStepDelta(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetStepDelta(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetStepDelta, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetStepDelta->OutputParameters();
    invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetStepDelta(IAsync& aAsync, TUint& aretStepDelta)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetStepDelta"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aretStepDelta = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncSetRampRate(TUint anewRampRate)
{
    SyncSetRampRateUpnpOrgDimming1C sync(*this);
    BeginSetRampRate(anewRampRate, sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginSetRampRate(TUint anewRampRate, FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionSetRampRate, aFunctor);
    TUint inIndex = 0;
    const Action::VectorParameters& inParams = iActionSetRampRate->InputParameters();
    invocation->AddInput(new ArgumentUint(*inParams[inIndex++], anewRampRate));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndSetRampRate(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("SetRampRate"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncGetRampRate(TUint& aretRampRate)
{
    SyncGetRampRateUpnpOrgDimming1C sync(*this, aretRampRate);
    BeginGetRampRate(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetRampRate(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetRampRate, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetRampRate->OutputParameters();
    invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetRampRate(IAsync& aAsync, TUint& aretRampRate)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetRampRate"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aretRampRate = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncPauseRamp()
{
    SyncPauseRampUpnpOrgDimming1C sync(*this);
    BeginPauseRamp(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginPauseRamp(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionPauseRamp, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndPauseRamp(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("PauseRamp"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncResumeRamp()
{
    SyncResumeRampUpnpOrgDimming1C sync(*this);
    BeginResumeRamp(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginResumeRamp(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionResumeRamp, aFunctor);
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndResumeRamp(IAsync& aAsync)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("ResumeRamp"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
}

void CpProxyUpnpOrgDimming1C::SyncGetIsRamping(TBool& aretIsRamping)
{
    SyncGetIsRampingUpnpOrgDimming1C sync(*this, aretIsRamping);
    BeginGetIsRamping(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetIsRamping(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetIsRamping, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetIsRamping->OutputParameters();
    invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetIsRamping(IAsync& aAsync, TBool& aretIsRamping)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetIsRamping"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aretIsRamping = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncGetRampPaused(TBool& aretRampPaused)
{
    SyncGetRampPausedUpnpOrgDimming1C sync(*this, aretRampPaused);
    BeginGetRampPaused(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetRampPaused(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetRampPaused, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetRampPaused->OutputParameters();
    invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetRampPaused(IAsync& aAsync, TBool& aretRampPaused)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetRampPaused"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aretRampPaused = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SyncGetRampTime(TUint& aretRampTime)
{
    SyncGetRampTimeUpnpOrgDimming1C sync(*this, aretRampTime);
    BeginGetRampTime(sync.Functor());
    sync.Wait();
}

void CpProxyUpnpOrgDimming1C::BeginGetRampTime(FunctorAsync& aFunctor)
{
    Invocation* invocation = Service()->Invocation(*iActionGetRampTime, aFunctor);
    TUint outIndex = 0;
    const Action::VectorParameters& outParams = iActionGetRampTime->OutputParameters();
    invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
    Invocable().InvokeAction(*invocation);
}

void CpProxyUpnpOrgDimming1C::EndGetRampTime(IAsync& aAsync, TUint& aretRampTime)
{
    ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
    Invocation& invocation = (Invocation&)aAsync;
    ASSERT(invocation.Action().Name() == Brn("GetRampTime"));

    Error::ELevel level;
    TUint code;
    const TChar* ignore;
    if (invocation.Error(level, code, ignore)) {
        THROW_PROXYERROR(level, code);
    }
    TUint index = 0;
    aretRampTime = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
}

void CpProxyUpnpOrgDimming1C::SetPropertyLoadLevelStatusChanged(Functor& aFunctor)
{
    iLock.Wait();
    iLoadLevelStatusChanged = aFunctor;
    iLock.Signal();
}

void CpProxyUpnpOrgDimming1C::SetPropertyStepDeltaChanged(Functor& aFunctor)
{
    iLock.Wait();
    iStepDeltaChanged = aFunctor;
    iLock.Signal();
}

void CpProxyUpnpOrgDimming1C::SetPropertyRampRateChanged(Functor& aFunctor)
{
    iLock.Wait();
    iRampRateChanged = aFunctor;
    iLock.Signal();
}

void CpProxyUpnpOrgDimming1C::SetPropertyIsRampingChanged(Functor& aFunctor)
{
    iLock.Wait();
    iIsRampingChanged = aFunctor;
    iLock.Signal();
}

void CpProxyUpnpOrgDimming1C::SetPropertyRampPausedChanged(Functor& aFunctor)
{
    iLock.Wait();
    iRampPausedChanged = aFunctor;
    iLock.Signal();
}

void CpProxyUpnpOrgDimming1C::PropertyLoadLevelStatus(TUint& aLoadLevelStatus) const
{
    AutoMutex a(GetPropertyReadLock());
    CheckSubscribed();
    aLoadLevelStatus = iLoadLevelStatus->Value();
}

void CpProxyUpnpOrgDimming1C::PropertyStepDelta(TUint& aStepDelta) const
{
    AutoMutex a(GetPropertyReadLock());
    CheckSubscribed();
    aStepDelta = iStepDelta->Value();
}

void CpProxyUpnpOrgDimming1C::PropertyRampRate(TUint& aRampRate) const
{
    AutoMutex a(GetPropertyReadLock());
    CheckSubscribed();
    aRampRate = iRampRate->Value();
}

void CpProxyUpnpOrgDimming1C::PropertyIsRamping(TBool& aIsRamping) const
{
    AutoMutex a(GetPropertyReadLock());
    CheckSubscribed();
    aIsRamping = iIsRamping->Value();
}

void CpProxyUpnpOrgDimming1C::PropertyRampPaused(TBool& aRampPaused) const
{
    AutoMutex a(GetPropertyReadLock());
    CheckSubscribed();
    aRampPaused = iRampPaused->Value();
}

void CpProxyUpnpOrgDimming1C::LoadLevelStatusPropertyChanged()
{
    ReportEvent(iLoadLevelStatusChanged);
}

void CpProxyUpnpOrgDimming1C::StepDeltaPropertyChanged()
{
    ReportEvent(iStepDeltaChanged);
}

void CpProxyUpnpOrgDimming1C::RampRatePropertyChanged()
{
    ReportEvent(iRampRateChanged);
}

void CpProxyUpnpOrgDimming1C::IsRampingPropertyChanged()
{
    ReportEvent(iIsRampingChanged);
}

void CpProxyUpnpOrgDimming1C::RampPausedPropertyChanged()
{
    ReportEvent(iRampPausedChanged);
}

THandle STDCALL CpProxyUpnpOrgDimming1Create(CpDeviceC aDevice)
{
    return new CpProxyUpnpOrgDimming1C(aDevice);
}

void STDCALL CpProxyUpnpOrgDimming1Destroy(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    delete proxyC;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetLoadLevelTarget(THandle aHandle, uint32_t anewLoadlevelTarget)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncSetLoadLevelTarget(anewLoadlevelTarget);
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginSetLoadLevelTarget(THandle aHandle, uint32_t anewLoadlevelTarget, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginSetLoadLevelTarget(anewLoadlevelTarget, functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndSetLoadLevelTarget(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndSetLoadLevelTarget(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetLoadLevelTarget(THandle aHandle, uint32_t* aGetLoadlevelTarget)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncGetLoadLevelTarget(*aGetLoadlevelTarget);
    }
    catch (ProxyError& ) {
        err = -1;
        *aGetLoadlevelTarget = 0;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetLoadLevelTarget(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetLoadLevelTarget(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetLoadLevelTarget(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aGetLoadlevelTarget)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndGetLoadLevelTarget(*async, *aGetLoadlevelTarget);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetLoadLevelStatus(THandle aHandle, uint32_t* aretLoadlevelStatus)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncGetLoadLevelStatus(*aretLoadlevelStatus);
    }
    catch (ProxyError& ) {
        err = -1;
        *aretLoadlevelStatus = 0;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetLoadLevelStatus(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetLoadLevelStatus(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetLoadLevelStatus(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretLoadlevelStatus)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndGetLoadLevelStatus(*async, *aretLoadlevelStatus);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetOnEffectLevel(THandle aHandle, uint32_t anewOnEffectLevel)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncSetOnEffectLevel(anewOnEffectLevel);
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginSetOnEffectLevel(THandle aHandle, uint32_t anewOnEffectLevel, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginSetOnEffectLevel(anewOnEffectLevel, functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndSetOnEffectLevel(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndSetOnEffectLevel(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetOnEffect(THandle aHandle, const char* anewOnEffect)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Brh buf_anewOnEffect(anewOnEffect);
    int32_t err = 0;
    try {
        proxyC->SyncSetOnEffect(buf_anewOnEffect);
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginSetOnEffect(THandle aHandle, const char* anewOnEffect, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Brh buf_anewOnEffect(anewOnEffect);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginSetOnEffect(buf_anewOnEffect, functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndSetOnEffect(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndSetOnEffect(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetOnEffectParameters(THandle aHandle, char** aretOnEffect, uint32_t* aretOnEffectLevel)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Brh buf_aretOnEffect;
    int32_t err = 0;
    try {
        proxyC->SyncGetOnEffectParameters(buf_aretOnEffect, *aretOnEffectLevel);
        *aretOnEffect = buf_aretOnEffect.Extract();
    }
    catch (ProxyError& ) {
        err = -1;
        *aretOnEffect = NULL;
        *aretOnEffectLevel = 0;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetOnEffectParameters(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetOnEffectParameters(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetOnEffectParameters(THandle aHandle, OhNetHandleAsync aAsync, char** aretOnEffect, uint32_t* aretOnEffectLevel)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    Brh buf_aretOnEffect;
    *aretOnEffect = NULL;
    try {
        proxyC->EndGetOnEffectParameters(*async, buf_aretOnEffect, *aretOnEffectLevel);
        *aretOnEffect = buf_aretOnEffect.Extract();
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncStepUp(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncStepUp();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginStepUp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginStepUp(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndStepUp(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndStepUp(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncStepDown(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncStepDown();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginStepDown(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginStepDown(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndStepDown(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndStepDown(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncStartRampUp(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncStartRampUp();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginStartRampUp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginStartRampUp(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndStartRampUp(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndStartRampUp(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncStartRampDown(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncStartRampDown();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginStartRampDown(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginStartRampDown(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndStartRampDown(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndStartRampDown(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncStopRamp(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncStopRamp();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginStopRamp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginStopRamp(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndStopRamp(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndStopRamp(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncStartRampToLevel(THandle aHandle, uint32_t anewLoadLevelTarget, uint32_t anewRampTime)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncStartRampToLevel(anewLoadLevelTarget, anewRampTime);
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginStartRampToLevel(THandle aHandle, uint32_t anewLoadLevelTarget, uint32_t anewRampTime, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginStartRampToLevel(anewLoadLevelTarget, anewRampTime, functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndStartRampToLevel(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndStartRampToLevel(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetStepDelta(THandle aHandle, uint32_t anewStepDelta)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncSetStepDelta(anewStepDelta);
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginSetStepDelta(THandle aHandle, uint32_t anewStepDelta, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginSetStepDelta(anewStepDelta, functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndSetStepDelta(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndSetStepDelta(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetStepDelta(THandle aHandle, uint32_t* aretStepDelta)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncGetStepDelta(*aretStepDelta);
    }
    catch (ProxyError& ) {
        err = -1;
        *aretStepDelta = 0;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetStepDelta(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetStepDelta(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetStepDelta(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretStepDelta)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndGetStepDelta(*async, *aretStepDelta);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetRampRate(THandle aHandle, uint32_t anewRampRate)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncSetRampRate(anewRampRate);
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginSetRampRate(THandle aHandle, uint32_t anewRampRate, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginSetRampRate(anewRampRate, functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndSetRampRate(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndSetRampRate(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetRampRate(THandle aHandle, uint32_t* aretRampRate)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncGetRampRate(*aretRampRate);
    }
    catch (ProxyError& ) {
        err = -1;
        *aretRampRate = 0;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetRampRate(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetRampRate(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetRampRate(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretRampRate)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndGetRampRate(*async, *aretRampRate);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncPauseRamp(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncPauseRamp();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginPauseRamp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginPauseRamp(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndPauseRamp(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndPauseRamp(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncResumeRamp(THandle aHandle)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncResumeRamp();
    }
    catch (ProxyError& ) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginResumeRamp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginResumeRamp(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndResumeRamp(THandle aHandle, OhNetHandleAsync aAsync)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndResumeRamp(*async);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetIsRamping(THandle aHandle, uint32_t* aretIsRamping)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    TBool retIsRamping;
    int32_t err = 0;
    try {
        proxyC->SyncGetIsRamping(retIsRamping);
        *aretIsRamping = retIsRamping? 1 : 0;
    }
    catch (ProxyError& ) {
        err = -1;
        *aretIsRamping = false;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetIsRamping(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetIsRamping(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetIsRamping(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretIsRamping)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    TBool retIsRamping;
    try {
        proxyC->EndGetIsRamping(*async, retIsRamping);
        *aretIsRamping = retIsRamping? 1 : 0;
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetRampPaused(THandle aHandle, uint32_t* aretRampPaused)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    TBool retRampPaused;
    int32_t err = 0;
    try {
        proxyC->SyncGetRampPaused(retRampPaused);
        *aretRampPaused = retRampPaused? 1 : 0;
    }
    catch (ProxyError& ) {
        err = -1;
        *aretRampPaused = false;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetRampPaused(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetRampPaused(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetRampPaused(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretRampPaused)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    TBool retRampPaused;
    try {
        proxyC->EndGetRampPaused(*async, retRampPaused);
        *aretRampPaused = retRampPaused? 1 : 0;
    }
    catch(...) {
        err = -1;
    }
    return err;
}

int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetRampTime(THandle aHandle, uint32_t* aretRampTime)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    int32_t err = 0;
    try {
        proxyC->SyncGetRampTime(*aretRampTime);
    }
    catch (ProxyError& ) {
        err = -1;
        *aretRampTime = 0;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1BeginGetRampTime(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    FunctorAsync functor = MakeFunctorAsync(aPtr, (OhNetFunctorAsync)aCallback);
    proxyC->BeginGetRampTime(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1EndGetRampTime(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretRampTime)
{
    int32_t err = 0;
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    IAsync* async = reinterpret_cast<IAsync*>(aAsync);
    ASSERT(async != NULL);
    try {
        proxyC->EndGetRampTime(*async, *aretRampTime);
    }
    catch(...) {
        err = -1;
    }
    return err;
}

void STDCALL CpProxyUpnpOrgDimming1SetPropertyLoadLevelStatusChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Functor functor = MakeFunctor(aPtr, aCallback);
    proxyC->SetPropertyLoadLevelStatusChanged(functor);
}

void STDCALL CpProxyUpnpOrgDimming1SetPropertyStepDeltaChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Functor functor = MakeFunctor(aPtr, aCallback);
    proxyC->SetPropertyStepDeltaChanged(functor);
}

void STDCALL CpProxyUpnpOrgDimming1SetPropertyRampRateChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Functor functor = MakeFunctor(aPtr, aCallback);
    proxyC->SetPropertyRampRateChanged(functor);
}

void STDCALL CpProxyUpnpOrgDimming1SetPropertyIsRampingChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Functor functor = MakeFunctor(aPtr, aCallback);
    proxyC->SetPropertyIsRampingChanged(functor);
}

void STDCALL CpProxyUpnpOrgDimming1SetPropertyRampPausedChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    Functor functor = MakeFunctor(aPtr, aCallback);
    proxyC->SetPropertyRampPausedChanged(functor);
}

int32_t STDCALL CpProxyUpnpOrgDimming1PropertyLoadLevelStatus(THandle aHandle, uint32_t* aLoadLevelStatus)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    try {
        proxyC->PropertyLoadLevelStatus(*aLoadLevelStatus);
    }
    catch (ProxyNotSubscribed&) {
        return -1;
    }
    return 0;
}

int32_t STDCALL CpProxyUpnpOrgDimming1PropertyStepDelta(THandle aHandle, uint32_t* aStepDelta)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    try {
        proxyC->PropertyStepDelta(*aStepDelta);
    }
    catch (ProxyNotSubscribed&) {
        return -1;
    }
    return 0;
}

int32_t STDCALL CpProxyUpnpOrgDimming1PropertyRampRate(THandle aHandle, uint32_t* aRampRate)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    try {
        proxyC->PropertyRampRate(*aRampRate);
    }
    catch (ProxyNotSubscribed&) {
        return -1;
    }
    return 0;
}

int32_t STDCALL CpProxyUpnpOrgDimming1PropertyIsRamping(THandle aHandle, uint32_t* aIsRamping)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    TBool IsRamping;
    try {
        proxyC->PropertyIsRamping(IsRamping);
    }
    catch (ProxyNotSubscribed&) {
        return -1;
    }
    *aIsRamping = IsRamping? 1 : 0;
    return 0;
}

int32_t STDCALL CpProxyUpnpOrgDimming1PropertyRampPaused(THandle aHandle, uint32_t* aRampPaused)
{
    CpProxyUpnpOrgDimming1C* proxyC = reinterpret_cast<CpProxyUpnpOrgDimming1C*>(aHandle);
    ASSERT(proxyC != NULL);
    TBool RampPaused;
    try {
        proxyC->PropertyRampPaused(RampPaused);
    }
    catch (ProxyNotSubscribed&) {
        return -1;
    }
    *aRampPaused = RampPaused? 1 : 0;
    return 0;
}


text:
"""
Module for interfacing with phonopy, see https://atztogo.github.io/phonopy/
"""

import numpy as np
from pymatgen.core import Structure, Lattice
from pymatgen.phonon.bandstructure import PhononBandStructureSymmLine, \
    PhononBandStructure
from pymatgen.phonon.dos import PhononDos, CompletePhononDos
from monty.serialization import loadfn
from monty.dev import requires

from pymatgen.symmetry.bandstructure import HighSymmKpath

try:
    from phonopy import Phonopy
    from phonopy.structure.atoms import PhonopyAtoms
    from phonopy.file_IO import write_disp_yaml
except ImportError:
    Phonopy = None

@requires(Phonopy, "phonopy not installed!")
def get_pmg_structure(phonopy_structure):
    """
    Convert a PhonopyAtoms object to pymatgen Structure object.

    Args:
        phonopy_structure (PhonopyAtoms): A phonopy structure object.

    """

    lattice = phonopy_structure.get_cell()
    frac_coords = phonopy_structure.get_scaled_positions()
    symbols = phonopy_structure.get_chemical_symbols()
    masses = phonopy_structure.get_masses()
    mms = phonopy_structure.get_magnetic_moments()
    mms = mms or [0] * len(symbols)

    return Structure(lattice, symbols, frac_coords,
                     site_properties={"phonopy_masses": masses,
                                      "magnetic_moments": mms})

@requires(Phonopy, "phonopy not installed!")
def get_phonopy_structure(pmg_structure):
    """
    Convert a pymatgen Structure object to a PhonopyAtoms object.

    Args:
        pmg_structure (pymatgen Structure): A Pymatgen structure object.

    """

    symbols = [site.specie.symbol for site in pmg_structure]

    return PhonopyAtoms(symbols=symbols, cell=pmg_structure.lattice.matrix,
                        scaled_positions=pmg_structure.frac_coords)

def get_structure_from_dict(d):
    """
    Extracts a structure from the dictionary extracted from the output
    files of phonopy like phonopy.yaml or band.yaml.
    Adds "phonopy_masses" in the site_properties of the structures.
    Compatible with older phonopy versions.
    """

    species = []
    frac_coords = []
    masses = []
    if 'points' in d:
        for p in d['points']:
            species.append(p['symbol'])
            frac_coords.append(p['coordinates'])
            masses.append(p['mass'])
    elif 'atoms' in d:
        for p in d['atoms']:
            species.append(p['symbol'])
            frac_coords.append(p['position'])
            masses.append(p['mass'])
    else:
        raise ValueError('The dict does not contain structural information')

    return Structure(d['lattice'], species, frac_coords,
                     site_properties={"phonopy_masses": masses})

def eigvec_to_eigdispl(v, q, frac_coords, mass):
    r"""
    Converts a single eigenvector to an eigendisplacement in the primitive cell
    according to the formula::

        exp(2*pi*i*(frac_coords \\dot q) / sqrt(mass) * v

    Compared to the modulation option in phonopy, here all the additional
    multiplicative and phase factors are set to 1.

    Args:
        v: the vector that should be converted. A 3D complex numpy array.
        q: the q point in fractional coordinates
        frac_coords: the fractional coordinates of the atom
        mass: the mass of the atom
    """

    c = np.exp(2j * np.pi * np.dot(frac_coords, q)) / np.sqrt(mass)

    return c * v

def get_ph_bs_symm_line_from_dict(bands_dict, has_nac=False, labels_dict=None):
    r"""
    Creates a pymatgen PhononBandStructure object from the dictionary
    extracted by the band.yaml file produced by phonopy. The labels
    will be extracted from the dictionary, if present. If the 'eigenvector'
    key is found the eigendisplacements will be calculated according to the
    formula::

        exp(2*pi*i*(frac_coords \\dot q) / sqrt(mass) * v

    and added to the object.

    Args:
        bands_dict: the dictionary extracted from the band.yaml file
        has_nac: True if the data have been obtained with the option
            --nac option. Default False.
        labels_dict: dict that links a qpoint in frac coords to a label.
            Its value will replace the data contained in the band.yaml.
    """

    structure = get_structure_from_dict(bands_dict)

    qpts = []
    frequencies = []
    eigendisplacements = []
    phonopy_labels_dict = {}
    for p in bands_dict['phonon']:
        q = p['q-position']
        qpts.append(q)
        bands = []
        eig_q = []
        for b in p['band']:
            bands.append(b['frequency'])
            if 'eigenvector' in b:
                eig_b = []
                for i, eig_a in enumerate(b['eigenvector']):
                    v = np.zeros(3, np.complex)
                    for x in range(3):
                        v[x] = eig_a[x][0] + eig_a[x][1] * 1j
                    eig_b.append(eigvec_to_eigdispl(
                        v, q, structure[i].frac_coords,
                        structure.site_properties['phonopy_masses'][i]))
                eig_q.append(eig_b)
        frequencies.append(bands)
        if 'label' in p:
            phonopy_labels_dict[p['label']] = p['q-position']
        if eig_q:
            eigendisplacements.append(eig_q)

    qpts = np.array(qpts)
    # transpose to match the convention in PhononBandStructure
    frequencies = np.transpose(frequencies)
    if eigendisplacements:
        eigendisplacements = np.transpose(eigendisplacements, (1, 0, 2, 3))

    rec_latt = Lattice(bands_dict['reciprocal_lattice'])

    labels_dict = labels_dict or phonopy_labels_dict

    ph_bs = PhononBandStructureSymmLine(
        qpts, frequencies, rec_latt, has_nac=has_nac, labels_dict=labels_dict,
        structure=structure, eigendisplacements=eigendisplacements)

    return ph_bs

def get_ph_bs_symm_line(bands_path, has_nac=False, labels_dict=None):
    r"""
    Creates a pymatgen PhononBandStructure from a band.yaml file.
    The labels will be extracted from the dictionary, if present.
    If the 'eigenvector'  key is found the eigendisplacements will be
    calculated according to the formula:
    \\exp(2*pi*i*(frac_coords \\dot q) / sqrt(mass) * v
     and added to the object.

    Args:
        bands_path: path to the band.yaml file
        has_nac: True if the data have been obtained with the option
            --nac option. Default False.
        labels_dict: dict that links a qpoint in frac coords to a label.
    """
    return get_ph_bs_symm_line_from_dict(loadfn(bands_path), has_nac,
                                         labels_dict)

def get_ph_dos(total_dos_path):
    """
    Creates a pymatgen PhononDos from a total_dos.dat file.

    Args:
        total_dos_path: path to the total_dos.dat file.
    """
    a = np.loadtxt(total_dos_path)
    return PhononDos(a[:, 0], a[:, 1])

def get_complete_ph_dos(partial_dos_path, phonopy_yaml_path):
    """
    Creates a pymatgen CompletePhononDos from a partial_dos.dat and
    phonopy.yaml files.
    The second is produced when generating a Dos and is needed to extract
    the structure.

    Args:
        partial_dos_path: path to the partial_dos.dat file.
        phonopy_yaml_path: path to the phonopy.yaml file.
    """
    a = np.loadtxt(partial_dos_path).transpose()
    d = loadfn(phonopy_yaml_path)

    structure = get_structure_from_dict(d['primitive_cell'])

    total_dos = PhononDos(a[0], a[1:].sum(axis=0))

    pdoss = {}
    for site, pdos in zip(structure, a[1:]):
        pdoss[site] = pdos.tolist()

    return CompletePhononDos(structure, total_dos, pdoss)

@requires(Phonopy, "phonopy not installed!")
def get_displaced_structures(pmg_structure, atom_disp=0.01,
                             supercell_matrix=None, yaml_fname=None, **kwargs):
    r"""
    Generate a set of symmetrically inequivalent displaced structures for
    phonon calculations.

    Args:
        pmg_structure (Structure): A pymatgen structure object.
        atom_disp (float): Atomic displacement. Default is 0.01 $\\AA$.
        supercell_matrix (3x3 array): Scaling matrix for supercell.
        yaml_fname (string): If not None, it represents the full path to
            the outputting displacement yaml file, e.g. disp.yaml.
        **kwargs: Parameters used in Phonopy.generate_displacement method.

    Return:
        A list of symmetrically inequivalent structures with displacements, in
        which the first element is the perfect supercell structure.
    """

    is_plusminus = kwargs.get("is_plusminus", "auto")
    is_diagonal = kwargs.get("is_diagonal", True)
    is_trigonal = kwargs.get("is_trigonal", False)

    ph_structure = get_phonopy_structure(pmg_structure)

    if supercell_matrix is None:
        supercell_matrix = np.eye(3) * np.array((1, 1, 1))

    phonon = Phonopy(unitcell=ph_structure, supercell_matrix=supercell_matrix)
    phonon.generate_displacements(distance=atom_disp,
                                  is_plusminus=is_plusminus,
                                  is_diagonal=is_diagonal,
                                  is_trigonal=is_trigonal)

    if yaml_fname is not None:
        displacements = phonon.get_displacements()
        write_disp_yaml(displacements=displacements,
                        supercell=phonon.get_supercell(),
                        filename=yaml_fname)

    # Supercell structures with displacement
    disp_supercells = phonon.get_supercells_with_displacements()
    # Perfect supercell structure
    init_supercell = phonon.get_supercell()
    # Structure list to be returned
    structure_list = [get_pmg_structure(init_supercell)]

    for c in disp_supercells:
        if c is not None:
            structure_list.append(get_pmg_structure(c))

    return structure_list

@requires(Phonopy, "phonopy is required to calculate phonon density of states")
def get_phonon_dos_from_fc(
    structure: Structure,
    supercell_matrix: np.ndarray,
    force_constants: np.ndarray,
    mesh_density: float = 100.,
    num_dos_steps: int = 200,
    **kwargs
) -> CompletePhononDos:
    """
    Get a projected phonon density of states from phonopy force constants.

    Args:
        structure: A structure.
        supercell_matrix: The supercell matrix used to generate the force
            constants.
        force_constants: The force constants in phonopy format.
        mesh_density: The density of the q-point mesh. See the docstring
            for the ``mesh`` argument in Phonopy.init_mesh() for more details.
        num_dos_steps: Number of frequency steps in the energy grid.
        **kwargs: Additional kwargs passed to the Phonopy constructor.

    Returns:
        The density of states.
    """
    structure_phonopy = get_phonopy_structure(structure)
    phonon = Phonopy(
        structure_phonopy, supercell_matrix=supercell_matrix, **kwargs
    )
    phonon.set_force_constants(force_constants)
    phonon.run_mesh(
        mesh_density,
        is_mesh_symmetry=False,
        with_eigenvectors=True,
        is_gamma_center=True,
    )

    # get min, max, step frequency
    frequencies = phonon.get_mesh_dict()["frequencies"]
    freq_min = frequencies.min()
    freq_max = frequencies.max()
    freq_pitch = (freq_max - freq_min) / num_dos_steps

    phonon.run_projected_dos(
        freq_min=freq_min, freq_max=freq_max, freq_pitch=freq_pitch
    )

    dos_raw = phonon.projected_dos.get_partial_dos()
    pdoss = {s: dos for s, dos in zip(structure, dos_raw[1])}

    total_dos = PhononDos(dos_raw[0], dos_raw[1].sum(axis=0))
    return CompletePhononDos(structure, total_dos, pdoss)

@requires(Phonopy, "phonopy is required to calculate phonon band structures")
def get_phonon_band_structure_from_fc(
    structure: Structure,
    supercell_matrix: np.ndarray,
    force_constants: np.ndarray,
    mesh_density: float = 100.0,
    **kwargs
) -> PhononBandStructure:
    """
    Get a uniform phonon band structure from phonopy force constants.

    Args:
        structure: A structure.
        supercell_matrix: The supercell matrix used to generate the force
            constants.
        force_constants: The force constants in phonopy format.
        mesh_density: The density of the q-point mesh. See the docstring
            for the ``mesh`` argument in Phonopy.init_mesh() for more details.
        **kwargs: Additional kwargs passed to the Phonopy constructor.

    Returns:
        The uniform phonon band structure.
    """
    structure_phonopy = get_phonopy_structure(structure)
    phonon = Phonopy(
        structure_phonopy, supercell_matrix=supercell_matrix, **kwargs
    )
    phonon.set_force_constants(force_constants)
    phonon.run_mesh(mesh_density, is_mesh_symmetry=False, is_gamma_center=True)
    mesh = phonon.get_mesh_dict()

    return PhononBandStructure(
        mesh["qpoints"], mesh["frequencies"], structure.lattice
    )

@requires(Phonopy, "phonopy is required to calculate phonon band structures")
def get_phonon_band_structure_symm_line_from_fc(
    structure: Structure,
    supercell_matrix: np.ndarray,
    force_constants: np.ndarray,
    line_density: float = 20.0,
    symprec: float = 0.01,
    **kwargs
) -> PhononBandStructureSymmLine:
    """
    Get a phonon band structure along a high symmetry path from phonopy force
    constants.

    Args:
        structure: A structure.
        supercell_matrix: The supercell matrix used to generate the force
            constants.
        force_constants: The force constants in phonopy format.
        line_density: The density along the high symmetry path.
        symprec: Symmetry precision passed to phonopy and used for determining
            the band structure path.
        **kwargs: Additional kwargs passed to the Phonopy constructor.

    Returns:
        The line mode band structure.
    """
    structure_phonopy = get_phonopy_structure(structure)
    phonon = Phonopy(
        structure_phonopy,
        supercell_matrix=supercell_matrix,
        symprec=symprec,
        **kwargs
    )
    phonon.set_force_constants(force_constants)

    kpath = HighSymmKpath(structure, symprec=symprec)

    kpoints, labels = kpath.get_kpoints(
        line_density=line_density, coords_are_cartesian=False
    )

    phonon.run_qpoints(kpoints)
    frequencies = phonon.qpoints.get_frequencies().T

    labels_dict = dict([(a, k) for a, k in zip(labels, kpoints) if a != ""])

    return PhononBandStructureSymmLine(
        kpoints, frequencies, structure.lattice, labels_dict=labels_dict
    )

redpajama_set_name: RedPajamaGithub


text:
/*
 * Copyright (C) 2004   MeVis gGmbH
 *
 _______________________________________________________________________
 ______________________  M E V I S   G G M B H  ________________________
 |
 |   $Revision$
 |
 |   Description:
 |   Macro file to implement exception handlers around some code to make
 |   code safe. In the case of caught exception an error message is composed
 |   and send to SoError.
 |   The usage of the exception handler is optional and can be enabled/disabled
 |   by the static class function SoCatch::enableExceptionHandling().
 |
 |   Author(s)      : Wolf Spindler, Felix Ritter
 |
 ______________________  M E V I S   G G M B H  ________________________
 _______________________________________________________________________
 */

#include <Inventor/SoCatch.h>
#include <Inventor/SoTrace.h>

SbBool SoCatch::_isExceptionHandlingEnabled=false;

SbBool
SoCatch::isExceptionHandlingEnabled()
{
   return _isExceptionHandlingEnabled;
}

void
SoCatch::enableExceptionHandling(SbBool on)
{
   _isExceptionHandlingEnabled = on;
}

void
SoCatch::initClass()
{
   _isExceptionHandlingEnabled = false;
}

void
SoCatch::postExceptionMessage(SoType      ERR_OBJ_TYPE_ID,
                              const char *OP_DESCR_STR,
                              SoType      ACTION_TYPE_ID,
                              const char *END_STR)
{
   SbString objName = "<unknown object>";
   try {
      if(ERR_OBJ_TYPE_ID != SoType::badType()) {
      	 objName = ERR_OBJ_TYPE_ID.getName().getString();
      }
   }
   catch(...) {
      objName="<error getting objTypeName>";
   }

   SbString opString = "";
   try {
      if(OP_DESCR_STR) {
      	 opString = OP_DESCR_STR;
      }
   }
   catch(...) {
      opString = "<error getting description>";
   }

   SbString actionName = "";
   try {
      if(ACTION_TYPE_ID != SoType::badType()) {
      	 actionName = ACTION_TYPE_ID.getName().getString();
      }
   }
   catch(...) {
      actionName="<error getting action type name>";
   }

   SbString endString = "";
   try {
      if(END_STR) {
      	 endString = END_STR;
      }
   }
   catch(...) {
      endString = "<error getting endStr name>";
   }

   SbString traceInfos ="";
   try {
      traceInfos = SoGlobalTraceBuffer.getTraceDumpString();
   }
   catch(...) {
      traceInfos="<error getting traceInfos name>";
   }

   try {
      SoError::post("Crash in %s while %s %s %s %s",
                    objName   .getString(),
                    opString  .getString(),
                    actionName.getString(),
                    endString .getString(),
                    traceInfos.getString());
   }
   catch(...) {
      SoError::post("<Could not create error message after catching error>");
   }
}


text:
"use strict";
var app = app || {};

app.Level = function(){

	//Ingame buttons
	function Level(level,colors,time)
	{
		this.level = level;
		this.colors = colors;
		this.time = time;
		this.completed = false;
		this.remainingTime = this.time;
	};

	var l = Level.prototype;

		l.update = function(elapsedTime)
		{
			if(this.remainingTime == 0)
			{
				return true;
			}

			this.remainingTime = this.time - elapsedTime;

			if(this.colors.length == 0)
			{
				this.completed = true;
			}

			return false;
		};

	// the "prototype" of this module
	return Level;
}();


text:
app.math = app.math || {};

/**
 * Trivial implementation of a range type and required operations.
 */
app.math.Range = (function () {

    var validateNumeric = function(value) {
        if (! $.isNumeric(value)) {
            throw value + ' is not a numeric value';
        }
    };

    return function (min, max) {

        validateNumeric(min);
        validateNumeric(max);

        if (max < min) {
            throw min + ' is not smaller or equals than ' + max;
        }

        var add = function (value) {
            validateNumeric(value);
            return new app.math.Range(min + value, max + value);
        };

        var addRange = function (range) {
            return new app.math.Range(min + range.min(), max + range.max());
        };

        var mul = function (value) {
            validateNumeric(value);
            return new app.math.Range(min * value, max * value);
        };

        var minimum = function () {
            return min;
        };

        var maximum = function () {
            return max;
        };

        var mean = function () {
            return (max + min) / 2;
        };

        return {
            add: add,
            addRange: addRange,
            mul: mul,
            mean: mean,
            min: minimum,
            max: maximum
        };
    };

})();


text:
package builds

import (
	"fmt"
	"strings"

	g "github.com/onsi/ginkgo"
	o "github.com/onsi/gomega"

	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	core "k8s.io/kubernetes/pkg/apis/core"
	e2e "k8s.io/kubernetes/test/e2e/framework"

	buildapi "github.com/openshift/origin/pkg/build/apis/build"
	exutil "github.com/openshift/origin/test/extended/util"
)

var _ = g.Describe("[Feature:Builds] Multi-stage image builds", func() {
	defer g.GinkgoRecover()
	var (
		oc             = exutil.NewCLI("build-multistage", exutil.KubeConfigPath())
		testDockerfile = `
FROM scratch as test
USER 1001
FROM centos:7
COPY --from=test /usr/bin/curl /test/
`
	)

	g.Context("", func() {

		g.JustBeforeEach(func() {
			g.By("waiting for builder service account")
			err := exutil.WaitForBuilderAccount(oc.KubeClient().Core().ServiceAccounts(oc.Namespace()))
			o.Expect(err).NotTo(o.HaveOccurred())

		})

		g.AfterEach(func() {
			if g.CurrentGinkgoTestDescription().Failed {
				exutil.DumpPodStates(oc)
				exutil.DumpPodLogsStartingWith("", oc)
			}
		})

		g.It("should succeed [Conformance]", func() {
			g.By("creating a build directly")
			build, err := oc.BuildClient().Build().Builds(oc.Namespace()).Create(&buildapi.Build{
				ObjectMeta: metav1.ObjectMeta{
					Name: "multi-stage",
				},
				Spec: buildapi.BuildSpec{
					CommonSpec: buildapi.CommonSpec{
						Source: buildapi.BuildSource{
							Dockerfile: &testDockerfile,
							Images: []buildapi.ImageSource{
								{From: core.ObjectReference{Kind: "DockerImage", Name: "centos:7"}, As: []string{"scratch"}},
							},
						},
						Strategy: buildapi.BuildStrategy{
							DockerStrategy: &buildapi.DockerBuildStrategy{},
						},
						Output: buildapi.BuildOutput{
							To: &core.ObjectReference{
								Kind: "DockerImage",
								Name: fmt.Sprintf("docker-registry.default.svc:5000/%s/multi-stage:v1", oc.Namespace()),
							},
						},
					},
				},
			})
			o.Expect(err).NotTo(o.HaveOccurred())
			result := exutil.NewBuildResult(oc, build)
			err = exutil.WaitForBuildResult(oc.AdminBuildClient().Build().Builds(oc.Namespace()), result)
			o.Expect(err).NotTo(o.HaveOccurred())

			pod, err := oc.KubeClient().CoreV1().Pods(oc.Namespace()).Get(build.Name+"-build", metav1.GetOptions{})
			o.Expect(err).NotTo(o.HaveOccurred())
			if !result.BuildSuccess && strings.HasSuffix(pod.Spec.Containers[0].Image, ":v3.10.0-alpha.0") {
				g.Skip(fmt.Sprintf("The currently selected builder image does not yet support optimized image builds: %s", pod.Spec.Containers[0].Image))
			}

			o.Expect(result.BuildSuccess).To(o.BeTrue(), "Build did not succeed: %#v", result)

			s, err := result.Logs()
			o.Expect(err).NotTo(o.HaveOccurred())
			o.Expect(s).ToNot(o.ContainSubstring("--> FROM scratch"))
			o.Expect(s).To(o.ContainSubstring("--> COPY --from"))
			o.Expect(s).To(o.ContainSubstring(fmt.Sprintf("\"OPENSHIFT_BUILD_NAMESPACE\"=\"%s\"", oc.Namespace())))
			o.Expect(s).To(o.ContainSubstring("--> Committing changes to "))
			e2e.Logf("Build logs:\n%s", result)

			c := oc.KubeFramework().PodClient()
			pod = c.Create(&corev1.Pod{
				ObjectMeta: metav1.ObjectMeta{
					Name: "test",
				},
				Spec: corev1.PodSpec{
					RestartPolicy: corev1.RestartPolicyNever,
					Containers: []corev1.Container{
						{
							Name:    "run",
							Image:   fmt.Sprintf("docker-registry.default.svc:5000/%s/multi-stage:v1", oc.Namespace()),
							Command: []string{"/test/curl", "-k", "https://kubernetes.default.svc"},
						},
					},
				},
			})
			c.WaitForSuccess(pod.Name, e2e.PodStartTimeout)
			data, err := c.GetLogs(pod.Name, &corev1.PodLogOptions{}).DoRaw()
			o.Expect(err).NotTo(o.HaveOccurred())
			e2e.Logf("Pod logs:\n%s", string(data))
		})
	})
})