itemman.cpp

OPCSERVER源代码

 if (free_tid)
   {
    loAA_FREE(tid);
   }

 if (FAILED(hr))
   {
    UL_TRACE((LOG_GRH("intValidateItems(%lu) = %s"), dwCount, loStrError(hr)));
   }
 else
   {
    *ppResults = ir, ir = 0;
    if (ppErrors) *ppErrors = err, err = 0;

    UL_TRACE((LOG_GRH("intValidateItems(%lu) = %s"), dwCount, loStrError(hr)));
   }
 if (ir)  loComFree(ir);
 if (err) loComFree(err);
 return hr;
}

/**************************************************************************/

STDMETHODIMP LightOPCGroup::RemoveItems(DWORD dwCount,
                                        OPCHANDLE *phServer,
                                        HRESULT **ppErrors)
{
 HRESULT hr = S_OK;
 HRESULT *err = 0;

 LO_CHECK_STATEz1("RemoveItems", ppErrors);

 if (!dwCount || !phServer) { hr = E_INVALIDARG; goto Return; }

 err = (HRESULT*)loComAlloc(dwCount * sizeof(HRESULT));
 if (!err) { hr = E_OUTOFMEMORY; goto Return; }

 lock_write();
   {
    DWORD ii;
    LightOPCItem *item;

    for(ii = 0; ii < dwCount;)
      {
       unsigned tt;
       loTagId ti[32];

       for(tt = 0; tt < SIZEOF_ARRAY(ti) && ii < dwCount; ii++)
         if (item = by_index((unsigned)phServer[ii]))
           {
            if (item->bActive)
              {
               active_count--;
               ti[tt++] = item->tid;
              }
            del((unsigned)phServer[ii]);
            err[ii] = S_OK;
           }
         else
           {
            err[ii] = OPC_E_INVALIDHANDLE;
            hr = S_FALSE;
           }
       if (tt && Active) loChangeActivity(&owner->ctxt.cactx, 0, tt, ti);
      }

   }
 unlock();

Return:
 if (FAILED(hr))
   {
    UL_INFO((LOG_GRH("RemoveItems(%lu) = %s"), dwCount, loStrError(hr)));
   }
 else
   {
    if (ppErrors) *ppErrors = err, err = 0;
    UL_NOTICE((LOG_GRH("RemoveItems(%lu) = %s"), dwCount, loStrError(hr)));
   }
 if (err) loComFree(err);
 LO_FINISH();
 return hr;
}

STDMETHODIMP LightOPCGroup::SetActiveState(DWORD dwCount,
                                           OPCHANDLE *phServer,
                                           BOOL bActive,
                                           HRESULT **ppErrors)
{
 HRESULT hr = S_OK;
 HRESULT *err = 0;
 int aqual = OPC_QUALITY_OUT_OF_SERVICE;
 unsigned aact = 0;

 LO_CHECK_STATEz1("SetActiveState", ppErrors);

 if (!dwCount || !phServer /*|| !ppErrors*/)
   { hr = E_INVALIDARG; goto Return; }

 err = (HRESULT*)loComAlloc(dwCount * sizeof(HRESULT));
 if (!err) { hr = E_OUTOFMEMORY; goto Return; }
 if (bActive = 0 != bActive) aqual = -1;

 lock_write();
   {
    DWORD ii;
    LightOPCItem *item;

    for(ii = 0; ii < dwCount;)
      {
       unsigned tt;
       loTagId ti[32];

       for(tt = 0; tt < SIZEOF_ARRAY(ti) && ii < dwCount; ii++)
         if (item = by_index((unsigned)phServer[ii]))
           {
            if (item->bActive != bActive /*&&
               (OPC_READABLE & tags[item->tid].attr.flag)*/)
              {
               aact++;
               item->bActive = bActive;
               ti[tt++] = item->tid;
               item->Quality = aqual;
               item->TouchChanged();
              }
            err[ii] = S_OK;
           }
         else
           {
            err[ii] = OPC_E_INVALIDHANDLE;
            hr = S_FALSE;
           }

       if (tt && Active) loChangeActivity(&owner->ctxt.cactx, bActive, tt, ti);
      }
    if (bActive)
      active_count += aact, last_trid = 0;
    else active_count -= aact;
   }
 unlock();

Return:

 if (FAILED(hr))
   {
    UL_INFO((LOG_GRH("SetActiveState(%lu, %u) = %s"),
                       dwCount, bActive, loStrError(hr)));
   }
 else
   {
    if (ppErrors) *ppErrors = err, err = 0;
    UL_NOTICE((LOG_GRH("SetActiveState(%lu, %u) = %s"),
                      dwCount, bActive, loStrError(hr)));
   }
 if (err) loComFree(err);

 LO_FINISH();
 return hr;
}

STDMETHODIMP LightOPCGroup::SetClientHandles(DWORD dwCount,
                                             OPCHANDLE *phServer,
                                             OPCHANDLE *phClient,
		                             HRESULT **ppErrors)
{
 HRESULT hr = S_OK;
 HRESULT *err = 0;

 LO_CHECK_STATEz1("SetClientHandles", ppErrors);

 if (!dwCount || !phServer || !phClient)
   { hr = E_INVALIDARG; goto Return; }

 err = (HRESULT*)loComAlloc(dwCount * sizeof(HRESULT));
 if (!err) { hr = E_OUTOFMEMORY; goto Return; }

 lock_write();
   {
    DWORD ii;
    LightOPCItem *item;

    for(ii = 0; ii < dwCount; ii++)
      if (item = by_index((unsigned)phServer[ii]))
	{
         item->hClient = phClient[ii];
         err[ii] = S_OK;
        }
      else
        {
         err[ii] = OPC_E_INVALIDHANDLE;
         hr = S_FALSE;
        }
   }
 unlock();

Return:

 if (FAILED(hr))
   {
    UL_INFO((LOG_GRH("SetClientHandles(%lu) = %s"), dwCount, loStrError(hr)));
   }
 else
   {
    if (ppErrors) *ppErrors = err, err = 0;
    UL_NOTICE((LOG_GRH("SetClientHandles(%lu) = %s"), dwCount, loStrError(hr)));
   }
 if (err) loComFree(err);

 LO_FINISH();
 return hr;
}

STDMETHODIMP LightOPCGroup::SetDatatypes(DWORD dwCount,
                                         OPCHANDLE *phServer,
                                         VARTYPE *pRequestedDatatypes,
		                         HRESULT **ppErrors)
{
 HRESULT hr = S_OK;
 HRESULT *err = 0;
 loTagEntry *te;
 loCallerx cctx;

 LO_CHECK_STATEz1("SetDatatypes", ppErrors);

 if (!dwCount || !phServer || !pRequestedDatatypes)
   { hr = E_INVALIDARG; goto Return; }

 err = (HRESULT*)loComAlloc(dwCount * sizeof(HRESULT));
 if (!err) { hr = E_OUTOFMEMORY; goto Return; }

 te = owner->se->tags;
 cctx = owner->ctxt;

 lock_write();
   {
    DWORD ii;
    LightOPCItem *item;
    cctx.cta.vc_lcid = grLCID;

    for(ii = 0; ii < dwCount; ii++)
      if (item = by_index((unsigned)phServer[ii]))
        {
         VARTYPE vt;
         loTagAttrib *ta;
        /* if (VT_EMPTY == (vt = pRequestedDatatypes[ii]))
           item->vtRequestedDataType = vt, err[ii] = S_OK;
         else */
         if (S_OK == (err[ii] = lo_checktype(&cctx,
                                  ta = &te[item->tid].attr,
				                  vt = pRequestedDatatypes[ii])))
           {
            item->vtRequestedDataType = vt;
            item->convtype = lo_check_conversion(ta, vt);
           }
         else hr = S_FALSE;
        }
      else
        {
         err[ii] = OPC_E_INVALIDHANDLE;
         hr = S_FALSE;
        }
   }
 unlock();

Return:

 if (FAILED(hr))
   {
    UL_INFO((LOG_GRH("SetDatatypes(%lu) = %s"), dwCount, loStrError(hr)));
   }
 else
   {
    if (ppErrors) *ppErrors = err, err = 0;
    UL_NOTICE((LOG_GRH("SetDatatypes(%lu) = %s"), dwCount, loStrError(hr)));
   }
 if (err) loComFree(err);
 LO_FINISH();
 return hr;
}

/* end of itemman.cpp */