Пример #1
0
void CheckpointTest::testGetComponentEvents()
{
  ComponentEventPtr p;
  string time("NOW"), value("123"),
    warning1("WARNING|CODE1|HIGH|Over..."),
    warning2("WARNING|CODE2|HIGH|Over..."),
    normal("NORMAL|||");
  std::set<string> filter;
  filter.insert(mDataItem1->getId());
  
  p = new ComponentEvent(*mDataItem1, 2, time, warning1);
  mCheckpoint->addComponentEvent(p);
  p->unrefer();
  
  p = new ComponentEvent(*mDataItem1, 2, time, warning2);
  mCheckpoint->addComponentEvent(p);
  p->unrefer();

  filter.insert(mDataItem2->getId());
  p = new ComponentEvent(*mDataItem2, 2, time, value);
  mCheckpoint->addComponentEvent(p);
  p->unrefer();
  
  std::map<string, string> attributes;
  attributes["id"] = "4";
  attributes["name"] = "DataItemTest2";
  attributes["type"] = "POSITION";
  attributes["nativeUnits"] = "MILLIMETER";
  attributes["subType"] = "ACTUAL";
  attributes["category"] = "SAMPLE";
  DataItem *d1 = new DataItem(attributes);
  filter.insert(d1->getId());
  
  p = new ComponentEvent(*d1, 2, time, value);
  mCheckpoint->addComponentEvent(p);
  p->unrefer();

  ComponentEventPtrArray list;
  mCheckpoint->getComponentEvents(list, &filter);

  CPPUNIT_ASSERT_EQUAL(4, (int) list.size());
  
  std::set<string> filter2;
  filter2.insert(mDataItem1->getId());

  ComponentEventPtrArray list2;
  mCheckpoint->getComponentEvents(list2, &filter2);

  CPPUNIT_ASSERT_EQUAL(2, (int) list2.size());
  
  delete d1;
}
void Checkpoint::getComponentEvents (ComponentEventPtrArray & aList,
                                     std::set<string> *       aFilter)
{
    map<string, ComponentEventPtr *>::iterator it;

    for ( it = mEvents.begin( ); it != mEvents.end( ); ++it )
    {
        ComponentEventPtr e = *( ( *it ).second );

        if ( ( aFilter == NULL ) || ( ( e.getObject( ) != NULL ) && ( aFilter->count(e->getDataItem( )->getId( )) > 0 ) ) )
        {
            while ( e.getObject( ) != NULL )
            {
                ComponentEventPtr p = e->getPrev( );
                aList.push_back(e);
                e = p;
            }
        }
    }
}
Пример #3
0
string XmlPrinter::printSample(const unsigned int instanceId,
                               const unsigned int bufferSize,
                               const uint64_t nextSeq,
                               const uint64_t firstSeq,
                               const uint64_t lastSeq,
                               ComponentEventPtrArray& results
  )
{
  xmlTextWriterPtr writer;
  xmlBufferPtr buf;
  string ret;
  
  try {
    THROW_IF_XML2_NULL(buf = xmlBufferCreate());
    THROW_IF_XML2_NULL(writer = xmlNewTextWriterMemory(buf, 0));
    THROW_IF_XML2_ERROR(xmlTextWriterSetIndent(writer, 1));
    THROW_IF_XML2_ERROR(xmlTextWriterSetIndentString(writer, BAD_CAST "  "));
    
    initXmlDoc(writer, eSTREAMS,
               instanceId,
               bufferSize,
               0, 0,
               nextSeq,
               firstSeq,
               lastSeq);
        
    THROW_IF_XML2_ERROR(xmlTextWriterStartElement(writer, BAD_CAST "Streams"));
    
    // Sort the vector by category.
    if (results.size() > 1)
      dlib::qsort_array<ComponentEventPtrArray,EventComparer>(results, 0, results.size() - 1, EventCompare);

    Device *lastDevice = NULL;
    Component *lastComponent = NULL;
    int lastCategory = -1;
    
    for (unsigned int i = 0; i < results.size(); i++)
    {
      ComponentEventPtr result = results[i];
      DataItem *dataItem = result->getDataItem();
      Component *component = dataItem->getComponent();
      Device *device = component->getDevice();
      
      if (device != lastDevice)
      {
        if (lastDevice != NULL)
          THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // DeviceStream
        lastDevice = device;
        if (lastComponent != NULL)
          THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // ComponentStream
        lastComponent = NULL;
        if (lastCategory != -1)
          THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // Category
        lastCategory = -1;
        addDeviceStream(writer, device);
      }
      
      if (component != lastComponent)
      {
        if (lastComponent != NULL)
          THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // ComponentStream
        lastComponent = component;
        if (lastCategory != -1)
          THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // Category
        lastCategory = -1;
        addComponentStream(writer, component);        
      }
      
      if (lastCategory != dataItem->getCategory())
      {
        if (lastCategory != -1)
          THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // Category
        lastCategory = dataItem->getCategory();
        addCategory(writer, dataItem->getCategory());
      }
      
      addEvent(writer, result);
    }
    
    if (lastCategory != -1)
      THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // Category
    if (lastDevice != NULL)
      THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // DeviceStream
    if (lastComponent != NULL)
      THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // ComponentStream
    
    THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // Streams    
    THROW_IF_XML2_ERROR(xmlTextWriterEndElement(writer)); // MTConnectStreams
    THROW_IF_XML2_ERROR(xmlTextWriterEndDocument(writer));
    
    xmlFreeTextWriter(writer);
    ret = (string) ((char*) buf->content);
    xmlBufferFree(buf);    
  }
  catch (string error) {
    if (buf != NULL)
      xmlBufferFree(buf);
    if (writer != NULL)
      xmlFreeTextWriter(writer);
    sLogger << dlib::LERROR << "printProbe: " << error;
  }
  catch (...) {
    if (buf != NULL)
      xmlBufferFree(buf);
    if (writer != NULL)
      xmlFreeTextWriter(writer);
    sLogger << dlib::LERROR << "printProbe: unknown error";
  }
  
  return ret;
}
void Checkpoint::addComponentEvent (ComponentEvent *anEvent)
{
    if ( mHasFilter )
    {
        if ( mFilter.count(anEvent->getDataItem( )->getId( )) == 0 )
        {
            return;
        }
    }

    DataItem *         item = anEvent->getDataItem( );
    string             id   = item->getId( );
    ComponentEventPtr *ptr  = mEvents[id];

    if ( ptr != NULL )
    {
        bool assigned = false;

        if ( item->isCondition( ) )
        {
            // Chain event only if it is normal or unavailable and the
            // previous condition was not normal or unavailable
            if ( ( ( *ptr )->getLevel( ) != ComponentEvent::NORMAL ) &&
                 ( anEvent->getLevel( ) != ComponentEvent::NORMAL ) &&
                 ( ( *ptr )->getLevel( ) != ComponentEvent::UNAVAILABLE ) &&
                 ( anEvent->getLevel( ) != ComponentEvent::UNAVAILABLE )
                 )
            {
                // Check to see if the native code matches an existing
                // active condition
                ComponentEvent *e = ( *ptr )->find(anEvent->getCode( ));

                if ( e != NULL )
                {
                    // Replace in chain.
                    ComponentEvent *n = ( *ptr )->deepCopyAndRemove(e);

                    // Check if this is the only event...
                    ( *ptr ) = n;

                    if ( n != NULL )
                    {
                        n->unrefer( );
                    }
                }

                // Chain the event
                if ( ptr->getObject( ) != NULL )
                {
                    anEvent->appendTo(*ptr);
                }
            }
            else if ( anEvent->getLevel( ) == ComponentEvent::NORMAL )
            {
                // Check for a normal that clears an active condition by code
                if ( anEvent->getCode( )[0] != '\0' )
                {
                    ComponentEvent *e = ( *ptr )->find(anEvent->getCode( ));

                    if ( e != NULL )
                    {
                        // Clear the one condition by removing it from the chain
                        ComponentEvent *n = ( *ptr )->deepCopyAndRemove(e);
                        ( *ptr ) = n;

                        if ( n != NULL )
                        {
                            n->unrefer( );
                        }
                        else
                        {
                            // Need to put a normal event in with no code since this
                            // is the last one.
                            n = new ComponentEvent(*anEvent);
                            n->normal( );
                            ( *ptr ) = n;
                            n->unrefer( );
                        }
                    }
                    else
                    {
                        // Not sure if we should register code specific normals if
                        // previous normal was not found
                        // (*ptr) = anEvent;
                    }
                    assigned = true;
                }
            }
        }

        if ( !assigned )
        {
            ( *ptr ) = anEvent;
        }
    }
    else
    {
        mEvents[id] = new ComponentEventPtr(anEvent);
    }
}