C++ Status::addDiagnostic方法代码示例

    // Manual unsubscription
    //==============================================================================================
    Status SubscriptionFactory::manuallyUnsubscribe(
            ClientSubscriptionHandle clientSubscriptionHandle)
    {
        Status ret;
        Subscription* subscription = 0;

        ret = acquireExistingSubscription(clientSubscriptionHandle, subscription);

        if (ret.isGood())
        {
            ret = subscription->deleteSubscription();
            releaseSubscription(subscription);
        }
        else
        {
            ret.addDiagnostic("Could not manually unsubscribe");
            logger_->error(ret);
        }

        return ret;
    }

    // Manual subscription
    //==============================================================================================
    Status SubscriptionFactory::manuallySubscribe(
            const SubscriptionSettings& settings,
            ClientSubscriptionHandle&   clientSubscriptionHandle)
    {
        Status ret;
        Subscription* subscription = 0;

        ret = acquireSubscription(settings, subscription);

        if (ret.isGood())
        {
            clientSubscriptionHandle = subscription->clientSubscriptionHandle();

            ret = releaseSubscription(subscription);
        }
        else
        {
            ret.addDiagnostic("Could not manually subscribe");
            logger_->error(ret);
        }

        return ret;
    }

    Status Subscription::createSubscription()
    {

        logger_->debug("Creating the subscription to the server");

        Status ret;

        UaClientSdk::ServiceSettings serviceSettings;

        UaClientSdk::SubscriptionSettings subscriptionSettings;
        subscriptionSettings = toSdk(subscriptionSettings_);

        UaStatus uaStatus = uaSession_->createSubscription(
                serviceSettings,
                uaSubscriptionCallback_,
                clientSubscriptionHandle_,
                subscriptionSettings,
                OpcUa_True,
                &uaSubscription_);

        ret.fromSdk(uaStatus.statusCode(), "Could not create the subscription to the server");

        if (ret.isGood())
        {
            subscriptionState_ = uafc::subscriptionstates::Created;
            logger_->debug("The subscription has been successfully created to the server");
        }
        else
        {
            subscriptionState_ = uafc::subscriptionstates::Deleted;
            ret.addDiagnostic("Subscription creation to the server failed");
            logger_->error(ret);
        }

        return ret;
    }

//.........这里部分代码省略.........
        logger_->debug(subscriptionSettings.toString());

        Status ret;

        subscription = 0;

        // lock the mutex to make sure the subscriptionMap_ is not being manipulated
        UaMutexLocker locker(&subscriptionMapMutex_);

        // we'll try to find a similar subscription that can be re-used,
        // unless we're creating an "unique" subscription
        // (one that is only created for -and used by- the current request)
        if (subscriptionSettings.unique)
        {
            logger_->debug("The requested subscription must be unique");
        }
        else
        {
            // loop trough the subscriptions ...
            for (SubscriptionMap::const_iterator it = subscriptionMap_.begin();
                 it != subscriptionMap_.end();
                 ++it)
            {
                // ... until a suitable one is found
                if (it->second->subscriptionSettings() == subscriptionSettings)
                {
                    subscription = it->second;
                    logger_->debug("A suitable subscription (ClientSubscriptionHandle=%d) already exists",
                                   subscription->clientSubscriptionHandle());

                    // get the ClientSubscriptionHandle of the subscription
                    ClientSubscriptionHandle handle = subscription->clientSubscriptionHandle();

                    // now increment the activity count of the subscription
                    activityMapMutex_.lock();
                    activityMap_[handle] = activityMap_[handle] + 1;
                    activityMapMutex_.unlock();

                    ret.setGood();

                    break;
                }
            }
        }

        // if no subscription exists yet, we create one
        if (subscription == 0)
        {
            ClientSubscriptionHandle clientSubscriptionHandle;
            clientSubscriptionHandle = database_->createUniqueClientSubscriptionHandle();

            logger_->debug("We create a new subscription with clientSubscriptionHandle %d",
                           clientSubscriptionHandle);

            // create a new subscription instance
            subscription = new Subscription(
                    logger_->loggerFactory(),
                    subscriptionSettings,
                    clientSubscriptionHandle,
                    clientConnectionId_,
                    uaSession_,
                    this,
                    clientInterface_,
                    database_);

            // store the new subscription instance in the subscriptionMap
            subscriptionMap_[clientSubscriptionHandle] = subscription;

            logger_->debug("The new subscription has been created");

            // create an activity count for the subscription
            activityMapMutex_.lock();
            activityMap_[clientSubscriptionHandle] = 1;
            activityMapMutex_.unlock();

            // create the subscription on the server
            ret = subscription->createSubscription();
        }

        // 'subscription' now points to an existing Subscription instance
        // (i.e. a valid memory location)

        ret.setGood();


        // add some diagnostics
        if (ret.isGood())
        {
            activityMapMutex_.lock();
            logger_->debug("The requested subscription is acquired (#activities: %d)",
                           activityMap_[subscription->clientSubscriptionHandle()]);
            activityMapMutex_.unlock();
        }
        else
        {
            logger_->error("The requested subscription could not be acquired");
            ret.addDiagnostic("The requested subscription could not be acquired");
        }
        return ret;
    }