Пример #1
0
	 T Parser::top_pop(std::stack<T>& input){
		 T temp = input.top();
		 input.pop();
		 return temp;
	 }
Пример #2
0
	void OnStartCluster(const std::string & id, const AttrMap & attrs)
	{
		assert(!id.empty());
		m_clusterStack.push(GetCluster(m_graph, m_clusterStack.top(), id, m_merge));
		m_clusterStack.top()->SetProperty(DOT_PROP_CDOTITEM, new CDotCluster(id, attrs));
	}
Пример #3
0
    void startElement(void *ctx, const char *name, const char **atts)
    {
        CC_UNUSED_PARAM(ctx);
        CC_UNUSED_PARAM(atts);
        const std::string sName(name);
        if( sName == "dict" )
        {
            if(_resultType == SAX_RESULT_DICT && _rootDict.empty())
            {
                _curDict = &_rootDict;
            }

            _state = SAX_DICT;

            SAXState preState = SAX_NONE;
            if (! _stateStack.empty())
            {
                preState = _stateStack.top();
            }

            if (SAX_ARRAY == preState)
            {
                // add a new dictionary into the array
                _curArray->push_back(Value(ValueMap()));
                _curDict = &(_curArray->rbegin())->asValueMap();
            }
            else if (SAX_DICT == preState)
            {
                // add a new dictionary into the pre dictionary
                CCASSERT(! _dictStack.empty(), "The state is wrong!");
                ValueMap* preDict = _dictStack.top();
                (*preDict)[_curKey] = Value(ValueMap());
                _curDict = &(*preDict)[_curKey].asValueMap();
            }

            // record the dict state
            _stateStack.push(_state);
            _dictStack.push(_curDict);
        }
        else if(sName == "key")
        {
            _state = SAX_KEY;
        }
        else if(sName == "integer")
        {
            _state = SAX_INT;
        }
        else if(sName == "real")
        {
            _state = SAX_REAL;
        }
        else if(sName == "string")
        {
            _state = SAX_STRING;
        }
        else if (sName == "array")
        {
            _state = SAX_ARRAY;

            if (_resultType == SAX_RESULT_ARRAY && _rootArray.empty())
            {
                _curArray = &_rootArray;
            }
            SAXState preState = SAX_NONE;
            if (! _stateStack.empty())
            {
                preState = _stateStack.top();
            }

            if (preState == SAX_DICT)
            {
                (*_curDict)[_curKey] = Value(ValueVector());
                _curArray = &(*_curDict)[_curKey].asValueVector();
            }
            else if (preState == SAX_ARRAY)
            {
                CCASSERT(! _arrayStack.empty(), "The state is wrong!");
                ValueVector* preArray = _arrayStack.top();
                preArray->push_back(Value(ValueVector()));
                _curArray = &(_curArray->rbegin())->asValueVector();
            }
            // record the array state
            _stateStack.push(_state);
            _arrayStack.push(_curArray);
        }
        else
        {
            _state = SAX_NONE;
        }
    }
Пример #4
0
	CGraphvizVisitor(IGraph * graph, bool merge) 
	{
		m_graph = graph;
		m_merge = merge;
		m_clusterStack.push(graph);
	}
Пример #5
0
	void OnStartGraph(int kind, const std::string & id, const AttrMap & attrs)
	{
		assert(!id.empty());
		m_graph->SetProperty(DOT_PROP_CDOTITEM, new CDotGraph(kind, id, attrs));
		m_clusterStack.push(NULL);
	}
Пример #6
0
LAS_DLL void LASError_Reset(void) {
    if (errors.empty()) return;
    for (std::size_t i=0;i<errors.size();i++) errors.pop();
}
Пример #7
0
LAS_DLL void LASError_PushError(int code, const char *message, const char *method) {
    LASError err = LASError(code, std::string(message), std::string(method));
    errors.push(err);
}
Пример #8
0
static Value DeserializeValue( std::string& str, bool* had_error, std::stack<StackDepthType>& depth_stack )
{
    Value v;

    *had_error = false;
    str = Trim( str );

    if ( str.length() == 0 )
        return v;

    if ( str[ 0 ] == '[' )
    {
        // This value is an array, determine the end of it and then deserialize the array
        depth_stack.push( InArray );
        size_t i = GetEndOfArrayOrObj( str, depth_stack );
        if ( i == std::string::npos )
        {
            *had_error = true;
            return Value();
        }

        std::string array_str = str.substr( 0, i + 1 );
        v = Value( DeserializeArray( array_str, depth_stack ) );
        str = str.substr( i + 1, str.length() );
    }
    else if ( str[ 0 ] == '{' )
    {
        // This value is an object, determine the end of it and then deserialize the object
        depth_stack.push( InObject );
        size_t i = GetEndOfArrayOrObj( str, depth_stack );

        if ( i == std::string::npos )
        {
            *had_error = true;
            return Value();
        }

        std::string obj_str = str.substr( 0, i + 1 );
        v = Value( DeserializeInternal( obj_str, depth_stack ) );
        str = str.substr( i + 1, str.length() );
    }
    else if ( str[ 0 ] == '\"' )
    {
        // This value is a string
        size_t end_quote = GetQuotePos( str, 1 );
        if ( end_quote == std::string::npos )
        {
            *had_error = true;
            return Value();
        }

        v = Value( UnescapeJSONString( str.substr( 1, end_quote - 1 ) ) );
        str = str.substr( end_quote + 1, str.length() );
    }
    else
    {
        // it's not an object, string, or array so it's either a boolean or a number or null.
        // Numbers can contain an exponent indicator ('e') or a decimal point.
        bool has_dot = false;
        bool has_e = false;
        std::string temp_val;
        size_t i = 0;
        bool found_digit = false;
        bool found_first_valid_char = false;

        for ( ; i < str.length(); i++ )
        {
            if ( str[ i ] == '.' )
            {
                if ( !found_digit )
                {
                    // As per JSON standards, there must be a digit preceding a decimal point
                    *had_error = true;
                    return Value();
                }

                has_dot = true;
            }
            else if ( ( str[ i ] == 'e' ) || ( str[ i ] == 'E' ) )
            {
                if ( ( _stricmp( temp_val.c_str(), "fals" ) != 0 ) && ( _stricmp( temp_val.c_str(), "tru" ) != 0 ) )
                {
                    // it's not a boolean, check for scientific notation validity. This will also trap booleans with extra 'e' characters like falsee/truee
                    if ( !found_digit )
                    {
                        // As per JSON standards, a digit must precede the 'e' notation
                        *had_error = true;
                        return Value();
                    }
                    else if ( has_e )
                    {
                        // multiple 'e' characters not allowed
                        *had_error = true;
                        return Value();
                    }

                    has_e = true;
                }
            }
            else if ( str[ i ] == ']' )
            {
                if ( depth_stack.empty() || ( depth_stack.top() != InArray ) )
                {
                    *had_error = true;
                    return Value();
                }

                depth_stack.pop();
            }
            else if ( str[ i ] == '}' )
            {
                if ( depth_stack.empty() || ( depth_stack.top() != InObject ) )
                {
                    *had_error = true;
                    return Value();
                }

                depth_stack.pop();
            }
            else if ( str[ i ] == ',' )
                break;
            else if ( ( str[ i ] == '[' ) || ( str[ i ] == '{' ) )
            {
                // error, we're supposed to be processing things besides arrays/objects in here
                *had_error = true;
                return Value();
            }

            if ( !std::isspace( str[ i ] ) )
            {
                if ( std::isdigit( str[ i ] ) )
                    found_digit = true;

                found_first_valid_char = true;
                temp_val += str[ i ];
            }
        }

        // store all floating point as doubles. This will also set the float and int values as well.
        if ( _stricmp( temp_val.c_str(), "true" ) == 0 )
            v = Value( true );
        else if ( _stricmp( temp_val.c_str(), "false" ) == 0 )
            v = Value( false );
        else if ( has_e || has_dot )
        {
            char* end_char;
            errno = 0;
            double d = strtod( temp_val.c_str(), &end_char );
            if ( ( errno != 0 ) || ( *end_char != '\0' ) )
            {
                // invalid conversion or out of range
                *had_error = true;
                return Value();
            }

            v = Value( d );
        }
        else if ( _stricmp( temp_val.c_str(), "null" ) == 0 )
            v = Value();
        else
        {
            // Check if the value is beyond the size of an int and if so, store it as a double
            char* end_char;
            errno = 0;
            long int ival = strtol( temp_val.c_str(), &end_char, 10 );
            if ( *end_char != '\0' )
            {
                // invalid character sequence, not a number
                *had_error = true;
                return Value();
            }
            else if ( ( errno == ERANGE ) && ( ( ival == LONG_MAX ) || ( ival == LONG_MIN ) ) )
            {
                // value is out of range for a long int, should be a double then. See if we can convert it correctly.
                errno = 0;
                double dval = strtod( temp_val.c_str(), &end_char );
                if ( ( errno != 0 ) || ( *end_char != '\0' ) )
                {
                    // error in conversion or it's too big for a double
                    *had_error = true;
                    return Value();
                }

                v = Value( dval );
            }
            else if ( ( ival >= INT_MIN ) && ( ival <= INT_MAX ) )
            {
                // valid integer range
                v = Value( (int)ival );
            }
            else
            {
                // probably running on a very old OS since this block implies that long isn't the same size as int.
                // int is guaranteed to be at least 16 bits and long 32 bits...however nowadays they're almost
                // always the same 32 bit size. But it's possible someone is running this on a very old architecture
                // so for correctness, we'll error out here
                *had_error = true;
                return Value();
            }
        }

        str = str.substr( i, str.length() );
    }

    return v;
}
Пример #9
0
void Pulsar::PlotLoop::plot( std::stack< Reference::To<TextIndex> >& indeces )
{
  if (indeces.empty())
  {
    VERBOSE("Pulsar::PlotLoop::plot plotting");

    for (unsigned i=0; i<plots.size(); i++)
    {
      if (!overlay)
        cpgpage ();

      plots[i]->plot (archives[i]);
    }
    return;
  }

  Reference::To<TextIndex> index = indeces.top();
  indeces.pop();

  vector<string> current (plots.size());

  unsigned loop_size = 0;
  for (unsigned iplot=0; iplot < plots.size(); iplot++)
  {
    index->set_container( archives[iplot]->get_interface() );

    if (iplot == 0)
      loop_size = index->size();
    else if ( loop_size != index->size() )
      throw Error (InvalidState, "Pulsar::PlotLoop::plot",
                   "loop size for plot[0]=%u != that of plot[%u]=%u",
                   loop_size, iplot, index->size());
  }

  for (unsigned i=0; i<loop_size; i++)
  {
    for (unsigned iplot=0; iplot < plots.size(); iplot++) try
    {
      index->set_container( archives[iplot]->get_interface() );

      string index_command = index->get_index(i);

      VERBOSE("Pulsar::PlotLoop::plot " << index_command);

      PlotLabel* label = plots[iplot]->get_attributes()->get_label_above();
      current[iplot] = label->get_centre();

      plots[iplot]->configure( index_command );
  
      label->set_centre( current[iplot] + " " + index_command );
    }
    catch (Error& error)
    {
      cerr << "Pulsar::PlotLoop::plot error configuring " << index->get_index(i)
           << " of "
           << "\n\t" << archives[iplot]->get_filename()
           << "\n\t" << error.get_message() << endl;
    }

    try
    {
      plot (indeces);
    }
    catch (Error& error)
    {
      cerr << "Pulsar::PlotLoop::plot error plotting " 
           << "\n\t" << error.get_message() << endl;
    }

    for (unsigned iplot=0; iplot < plots.size(); iplot++)
    {
      PlotLabel* label = plots[iplot]->get_attributes()->get_label_above();
      label->set_centre( current[iplot] );
    }
  }

  indeces.push( index );
}
Пример #10
0
 void ObjectHandle::free()
 {
   freedHandles.push((int64)*this);
 }
Пример #11
0
static Value DeserializeValue(std::string& str, bool* had_error, std::stack<StackDepthType>& depth_stack)
{
	Value v;

	*had_error = false;
	str = Trim(str);

	if (str.length() == 0)
		return v;

	if (str[0] == '[')
	{
		// This value is an array, determine the end of it and then deserialize the array
		depth_stack.push(InArray);
		size_t i = GetEndOfArrayOrObj(str, depth_stack);
		if (i == std::string::npos)
		{
			*had_error = true;
			return Value();
		}
		
		std::string array_str = str.substr(0, i + 1);
		v = Value(DeserializeArray(array_str, depth_stack));
		str = str.substr(i + 1, str.length());
	}
	else if (str[0] == '{')
	{
		// This value is an object, determine the end of it and then deserialize the object
		depth_stack.push(InObject);
		size_t i = GetEndOfArrayOrObj(str, depth_stack);

		if (i == std::string::npos)
		{
			*had_error = true;
			return Value();
		}

		std::string obj_str = str.substr(0, i + 1);
		v = Value(DeserializeInternal(obj_str, depth_stack));
		str = str.substr(i + 1, str.length());
	}
	else if (str[0] == '\"')
	{
		// This value is a string
		size_t end_quote = GetQuotePos(str, 1);
		if (end_quote == std::string::npos)
		{
			*had_error = true;
			return Value();
		}

		v = Value(UnescapeJSONString(str.substr(1, end_quote - 1)));
		str = str.substr(end_quote + 1, str.length());
	}
	else
	{
		// it's not an object, string, or array so it's either a boolean or a number or null.
		// Numbers can contain an exponent indicator ('e') or a decimal point.
		bool has_dot = false;
		bool has_e = false;
		std::string temp_val;
		size_t i = 0;
		for (; i < str.length(); i++)
		{
			if (str[i] == '.')
				has_dot = true;
			else if ((str[i] == 'e') || (str[i] == 'E'))
				has_e = true;
			else if (str[i] == ']')
			{
				if (depth_stack.top() != InArray)
				{
					*had_error = true;
					return Value();
				}
				
				depth_stack.pop();
			}
			else if (str[i] == '}')
			{
				if (depth_stack.top() != InObject)
				{
					*had_error = true;
					return Value();
				}
				
				depth_stack.pop();
			}
			else if (str[i] == ',')
				break;

			if (!std::isspace(str[i]))
				temp_val += str[i];
		}

		// store all floating point as doubles. This will also set the float and int values as well.
		if (_stricmp(temp_val.c_str(), "true") == 0)
			v = Value(true);
		else if (_stricmp(temp_val.c_str(), "false") == 0)
			v = Value(false);
		else if (has_e || has_dot)
			v = Value(atof(temp_val.c_str()));
		else if (_stricmp(temp_val.c_str(), "null") == 0)
			v = Value();
		else
		{
			// Check if the value is beyond the size of an int and if so, store it as a double
			double tmp_val = atof(temp_val.c_str());
			if ((tmp_val >= (double)INT_MIN) && (tmp_val <= (double)INT_MAX))
				v = Value(atoi(temp_val.c_str()));
			else
				v = Value(tmp_val);
		}

		str = str.substr(i, str.length());
	}

	return v;
}
Пример #12
0
namespace ospray {

  static std::map<int64,Ref<ospray::ManagedObject>> objectByHandle;
  static std::stack<int64> freedHandles;

  //! next unassigned ID on this node
  /*! we start numbering with 1 to make sure that "0:0" is an
    invalid handle (so we can typecast between (64-bit) handles
    and (64-bit)OSPWhatEver pointers */
  static int32 nextFreeLocalID = 1;

  void ObjectHandle::free()
  {
    freedHandles.push((int64)*this);
  }

  ObjectHandle::ObjectHandle()
  {
    if (freedHandles.empty()) {
      i32.ID    = nextFreeLocalID++;
      i32.owner = 0;
    } else {
      i64 = freedHandles.top();
      freedHandles.pop();
    }
  }

  ObjectHandle::ObjectHandle(int64 i) : i64(i)
  {
  }

  ObjectHandle::ObjectHandle(const ObjectHandle &other) : i64(other.i64)
  {
  }

  ObjectHandle &ObjectHandle::operator=(const ObjectHandle &other)
  {
    i64 = other.i64;
    return *this;
  }

  /*! define the given handle to refer to given object */
  void ObjectHandle::assign(const ObjectHandle &handle, ManagedObject *object)
  {
    objectByHandle[handle] = object;
  }

  void ObjectHandle::assign(ManagedObject *object) const
  {
    objectByHandle[*this] = object;
  }

  void ObjectHandle::freeObject() const
  {
    auto it = objectByHandle.find(i64);
    Assert(it != objectByHandle.end());
    it->second = nullptr;
    objectByHandle.erase(it);
  }

  int32 ObjectHandle::ownerRank() const
  {
    return i32.owner;
  }

  int32 ObjectHandle::objID() const
  {
    return i32.ID;
  }

  ospray::ObjectHandle::operator int64() const
  {
    return i64;
  }

  bool ObjectHandle::defined() const
  {
    auto it = objectByHandle.find(i64);
    return it != objectByHandle.end();
  }

  ManagedObject *ObjectHandle::lookup() const
  {
    if (i64 == 0) return nullptr;

    auto it = objectByHandle.find(i64);
    if (it == objectByHandle.end()) {
#ifndef NDEBUG
      // iw - made this into a warning only; the original code had
      // this throw an actual exceptoin, but that may be overkill
      std::cout << "#osp: WARNING: ospray is trying to look up object handle "+std::to_string(i64)+" that isn't defined!" << std::endl;
#endif
      return nullptr;
    }
    return it->second.ptr;
  }

  ObjectHandle ObjectHandle::lookup(ManagedObject *object)
  {
    for (auto it = objectByHandle.begin(); it != objectByHandle.end(); it++) {
      if (it->second.ptr == object) return(ObjectHandle(it->first));
    }

    return(nullHandle);
  }

  OSPRAY_SDK_INTERFACE const ObjectHandle nullHandle(0);

} // ::ospray
Пример #13
0
/*! \brief return current camera picture, as rgb or yuv picture, threadsave
 *
 * \param rgb if set to zero (default), yuv-Picture will return, <br>
 *            if set to other value, rgb-Picture will return
 * \param removeFrame if set to 1 (default) the next picture will be catch <br>
 *                    if set to zero, the last picture will be returned
 * \return SPicture pointer to lokal buffer, which didn't change until the next call from getPicture with
 *         the same rgb-parameter
 * \return NULL if any error occured
 */
SPicture* getPicture(int rgb/* = 0*/, int removeFrame/* = 1*/)
{
    if(mutex_lock(mutex))
        g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_lock</font>"));

    // if start wasn't called
    if(!g_run)
    {
        while(g_capture.isOpened())
            g_capture.release();
        printf("encoder.getPicture after call g_capture.release\n");
        g_Messages.push(string("getPicture</b> <font color='blue'>Kamera wurde geschlossen</font>"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 1</font>"));
        return 0;
    }
    // try to open capture
    else if(!g_capture.isOpened())
    {
        g_Messages.push(string("getPicture</b> <font color='red'>keine Kamera geoeffnet!</font>"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 2</font>"));
        return 0;
    }


    //get next or last picture
    Mat m, m2, m3;
    if(!removeFrame)
        g_capture.retrieve(m);
    else
        g_capture >> m; // get a new frame from camer

    if(!m.size().area())
    {
        g_Messages.push(string("getPicture</b> <font color='red'>picture from camera is empty</font>"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 3</font>"));
        return 0;
    }

    //m = cvLoadImage("test.jpg");
    if(m.depth() != CV_8U)
    {
        g_Messages.push(string("getPicture</b> <font color='red'>depth != unsigned char</font>\n"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 4</font>"));
        return 0;
    }
    //m.convertTo(m2, )
    //Scale Picture to choosen resolution (if camera didn't support it)
    Mat matrices[4];
    //IplImage src = m;
    //  IplImage* scaled = cvCreateImage(cvSize(g_cfg.width, g_cfg.height), IPL_DEPTH_8U, 3);

    //cvResize( &src, scaled, CV_INTER_LINEAR );
    m3.create(g_cfg.width, g_cfg.height, m.type());
    resize(m, m3, Size(g_cfg.width, g_cfg.height));

    char buffer[256];
    sprintf(buffer, "getPicture</b> <i>breite: %d, hoehe: %d, area: %d</i>", m.size().width, m.size().height, m.size().area());
    // g_Messages.push(string(buffer));

    //rgb-output
    if(rgb)
    {
        //imshow("LIVE", scaled);
        split(m3, matrices);
        matrices[3] = matrices[0].clone();
        matrices[3] = Scalar(255);
        merge(matrices, 4, m2);

        //get current buffer size and required buffer size
        int oldSize = picture_getSize(&g_rgbPicture);
        g_rgbPicture.width = m2.cols;
        g_rgbPicture.height = m2.rows;
        int newSize = picture_getSize(&g_rgbPicture);

        //compare buffer size and picture size, and make new buffer, if picture size differ
        if(oldSize != newSize)
        {
            picture_release(&g_rgbPicture);
            if(picture_create(&g_rgbPicture, m2.cols, m2.rows, 4))
            {
                g_Messages.push(string("getPicture</b> <font color='red'>Fehler beim speicher reservieren in getPicture rgb!</font>"));
                if(mutex_unlock(mutex))
                    g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 5</font>"));
                return NULL;
            }
        }

        //return 0;
        //copy picture to buffer
        size_t size = m2.cols*m2.rows*4;
        memcpy(g_rgbPicture.channel1, m2.data, size);

        //free scaled image
        //cvReleaseImage(&scaled);

        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 6</font>"));
        //return pointer to picture buffer
        return &g_rgbPicture;

    }
    // yuv-Output
    else
    {
        //convert and split picture
        cvtColor(m3, m2, CV_BGR2YCrCb);
        split(m2, matrices);

        IplImage* U = cvCreateImage(cvSize(m3.cols/2, m3.rows/2), IPL_DEPTH_8U, 1);
        IplImage* V = cvCreateImage(cvSize(m3.cols/2, m3.rows/2), IPL_DEPTH_8U, 1);
        IplImage uSrc = matrices[1];
        IplImage vSrc = matrices[2];
        //create resized u and v pictures (half-size)
        cvResize(&uSrc, U, CV_INTER_LINEAR);
        cvResize( &vSrc, V, CV_INTER_LINEAR );
        //  imshow("Y", matrices[0]);
        //imshow("U", U);
        //imshow("V", V);

        //get current buffer size and required buffer size
        int oldSize = picture_getSize(&g_yuvPicture);
        g_yuvPicture.width = m3.cols;
        g_yuvPicture.height = m3.rows;
        int newSize = picture_getSize(&g_yuvPicture);

        //compare buffer size and picture size, and make new buffer, if picture size differ
        if(oldSize != newSize)
        {
            picture_release(&g_yuvPicture);
            if(picture_create(&g_yuvPicture, m2.cols, m2.rows, 1))
            {
                g_Messages.push(string("getPicture</b> <font color='red'>Fehler beim speicher reservieren in getPicture yuv!</font>"));
                if(mutex_unlock(mutex))
                    g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 7</font>"));
                return 0;
            }
        }
        //return 0;
        //copy channels
        size_t size = m2.cols*m2.rows;
        memcpy(g_yuvPicture.channel1, matrices[0].data, size);
        memcpy(g_yuvPicture.channel2, V->imageData, size/4);
        memcpy(g_yuvPicture.channel3, U->imageData, size/4);

        //release u and v pictures
        cvReleaseImage(&U);
        cvReleaseImage(&V);
//       cvReleaseImage(&scaled);

        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 8</font>"));
        //return pointer to picture buffer
        return &g_yuvPicture;
    }

    if(mutex_unlock(mutex))
        g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 9</font>"));
    return NULL;
}
Пример #14
0
/*! \brief get parameter from capture
 *
 *
 * <br>
 * <table><tr><th colspan='3'>Possible Parameters to get:</th></tr>
 * <tr><th>name</th><th>return</th><th>description</th></tr>
 * <tr><td>getLastMessage</td><td>char[256]</td><td>
 *    - return pointer to char-buffer with last error-message from capture</td></tr>
 * <tr><td>capture.getPictureFunc</td>
 *     <td>(SPicture* (*)(int, int))</td><td>
 *     - return pointer to getPicture(int rgb, int removeFrame)</td></tr>
 * <tr><td>capture.camera.count</td><td>int</td><td>
 *     - return number of cameras currently connected to the Computer</td></tr>
 * <tr><td>capture.camera.x.name</td><td>char[]</td><td>
 *     - return name of camera x, where x is a number between 0 and capture.camera.count</td></tr>
 * <tr><td>capture.camera.x.resolution.count</td><td>int</td><td>
 *     - return number of resolutions for camera x (where x is a number between 0 and capture.camera.count)</td></tr>
 * <tr><td>capture.camera.i.resolution.j.x<br>capture.camera.i.resolution.j.width</td><td>int</td><td>
 *     - return resolution width of camera i, of resolution j
 *      (where i is a number between 0 and capture.camera.count
 *       and j is a number between 0 and capture.camera.i.resolution.count)</td></tr>
 * <tr><td>capture.camera.i.resolution.j.y<br>capture.camera.i.resolution.j.height</td><td>int</td><td>
 *     - return resolution height of camera i, of resolution j
 *      (where i is a number between 0 and capture.camera.count
 *       and j is a number between 0 and capture.camera.i.resolution.count)</td></tr>
 * <tr><td>capture.resolution.x<br>capture.resolution.width</td>
 *     <td>int</td><td>
 *     - return current width of camera resolution</td></tr>
 * <tr><td>capture.resolution.y<br>capture.resolution.height</td>
 *     <td>int</td><td>
 *     - return current height of camera resolution</td></tr>
 * </table>
 * <br>
 *
 * \param name parameter name
 * \return parameter value (number or pointer) if succeed
 * \return NULL if parameter is unknown
 */
int getParameter(const char* name)
{
    if(mutex_lock(mutex))
        printf("capture.getParameter Fehler bei lock_mutex\n");

    // printf("Name: %s\n", name);
    char buffer[256];
    sprintf(buffer, "%s", name);


    char * pch;
    pch = strtok (buffer, ".\0");
    int count = 0;
    while (pch != NULL)
    {
        g_Parameters[count++] = pch;
        pch = strtok (NULL, ".\0");

    }
    if(g_Parameters[0] == string("getLastMessage"))
    {
        if(g_Messages.size())
        {
            sprintf(g_MessagesBuffer,"<b>capture.%s", g_Messages.top().data());
            g_Messages.pop();
            if(mutex_unlock(mutex)) printf("capture.getParameter Fehler bei unlock_mutex 1\n");
            return (int)g_MessagesBuffer;
        }
        else
        {
            if(mutex_unlock(mutex)) printf("capture.getParameter Fehler bei unlock_mutex 2\n");
            return 0;
        }
    }
    else if(g_Parameters[0] != string(g_modulname))
    {
        //TODO: weiterleiten
        if(mutex_unlock(mutex)) printf("capture.getParameter Fehler bei unlock_mutex 3\n");
        return 0;
    }
    if(g_Parameters[1] == string("camera"))
    {
        return camera_getParameter(&g_Parameters[2]);
    }
    else if(g_Parameters[1] == string("getPictureFunc") )
    {
        if(mutex_unlock(mutex)) printf("capture.getParameter Fehler bei unlock_mutex 4\n");
        return (int)getPicture;
    }
    else if(string(name) == string("capture.resolution.x") ||
            string(name) == string("capture.resolution.width"))
    {


        int width = g_cfg.width;
        if(mutex_unlock(mutex)) printf("capture.getParameter Fehler bei unlock_mutex 5\n");
        return width;
    }
    else if(string(name) == string("capture.resolution.y") ||
            string(name) == string("capture.resolution.height"))
    {
        int height = g_cfg.height;
        if(mutex_unlock(mutex)) printf("capture.getParameter Fehler bei unlock_mutex 6\n");
        return height;
    }


    /*  for(int i = 0; i < MAX_PARAMETER_COUNT; i++)
      {
          printf("%d: %s\n", i, g_Parameters[i].data());
      }*/
    return 0;

}
Пример #15
0
 void PushExpListValueCount(int count)
 {
     exp_list_value_count_.push(count);
 }
Пример #16
0
inline void push( std::stack<StackValueType> &s, T t ) {
  s.push( t );
}
Пример #17
0
void MyCompressData::AnalysisWildCard(const char *inWildCard,char *outFileList,std::stack<std::string>& ioStack)
{
	bool theStartFlag = 1;
	if(outFileList[0] != '\0')
	{
		theStartFlag = 0;
	}
	HANDLE hFind;
	WIN32_FIND_DATA fd;
	//================================
	//ワイルドカード使用時
	//================================
	hFind = FindFirstFile(inWildCard, &fd);		
		
	//検索失敗
	if(hFind == INVALID_HANDLE_VALUE) 
	{
		return;
	}
			
	//===================================
	//ディレクトリの名前取得
	//===================================
	char theDirName[256];
	strcpy(theDirName,inWildCard);
	for(int i = (int)strlen(theDirName); i >= 0; i--)
	{
		if(theDirName[i] == '/')
		{
			theDirName[i + 1] = '\0';
			break;
		}
	}

	
	char theBuffer[256];
	do 
	{
		if(!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) 
		{
			if(theStartFlag == 0)
			{
				strcat(outFileList,",");
			}
			strcat(outFileList,theDirName);
			strcat(outFileList,fd.cFileName);
			theStartFlag = 0;
		}
		else if(fd.cFileName[0] != '.')
		{
			strcpy(theBuffer,theDirName);
			strcat(theBuffer,fd.cFileName);
			strcat(theBuffer,"/");
			strcat(theBuffer,"*");
			ioStack.push(std::string(theBuffer));
		}
	} while(FindNextFile(hFind, &fd));

    FindClose(hFind);



}
Пример #18
0
/**
 * An exception-safe push-and-release function for unique_ptr objects: the
 * unique_ptr will be released only if pushing succeeds.
 *
 * @tparam StackValueType The stack's \c value_type.
 * @tparam PointedToType The pointed-to type.
 * @param s The stack to push onto.
 * @param p A pointer to the object to push.
 */
template<typename StackValueType,typename PointedToType> inline
void push( std::stack<StackValueType> &s, std::unique_ptr<PointedToType> &p ) {
  s.push( p.get() );
  p.release();
}
Пример #19
0
LAS_DLL void LASError_Pop(void) {
    if (errors.empty()) return;
    errors.pop();
}
 void endElement(void *ctx, const char *name)
 {
     CC_UNUSED_PARAM(ctx);
     CCSAXState curState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
     std::string sName((char*)name);
     if( sName == "dict" )
     {
         m_tStateStack.pop();
         m_tDictStack.pop();
         if ( !m_tDictStack.empty())
         {
             m_pCurDict = m_tDictStack.top();
         }
     }
     else if (sName == "array")
     {
         m_tStateStack.pop();
         m_tArrayStack.pop();
         if (! m_tArrayStack.empty())
         {
             m_pArray = m_tArrayStack.top();
         }
     }
     else if (sName == "true")
     {
         CCString *str = new CCString("1");
         if (SAX_ARRAY == curState)
         {
             m_pArray->addObject(str);
         }
         else if (SAX_DICT == curState)
         {
             m_pCurDict->setObject(str, m_sCurKey.c_str());
         }
         str->release();
     }
     else if (sName == "false")
     {
         CCString *str = new CCString("0");
         if (SAX_ARRAY == curState)
         {
             m_pArray->addObject(str);
         }
         else if (SAX_DICT == curState)
         {
             m_pCurDict->setObject(str, m_sCurKey.c_str());
         }
         str->release();
     }
     else if (sName == "string" || sName == "integer" || sName == "real")
     {
         CCString* pStrValue = new CCString(m_sCurValue);
         
         if (SAX_ARRAY == curState)
         {
             m_pArray->addObject(pStrValue);
         }
         else if (SAX_DICT == curState)
         {
             m_pCurDict->setObject(pStrValue, m_sCurKey.c_str());
         }
         
         pStrValue->release();
         m_sCurValue.clear();
     }
     
     m_tState = SAX_NONE;
 }
Пример #21
0
LAS_DLL int LASError_GetErrorCount(void) {
    return static_cast<int>(errors.size());
}
Пример #22
0
    void startElement(void *ctx, const char *name, const char **atts)
    {
        CC_UNUSED_PARAM(ctx);
        CC_UNUSED_PARAM(atts);
        std::string sName((char*)name);
        if( sName == "dict" )
        {
            m_pCurDict = new CCDictionary<std::string, CCObject*>();
            if (m_eResultType == SAX_RESULT_DICT && ! m_pRootDict)
            {
				// Because it will call m_pCurDict->release() later, so retain here.
                m_pRootDict = m_pCurDict;
				m_pRootDict->retain();
            }
            m_tState = SAX_DICT;

            CCSAXState preState = SAX_NONE;
            if (! m_tStateStack.empty())
            {
                preState = m_tStateStack.top();
            }

            if (SAX_ARRAY == preState)
            {
                // add the dictionary into the array
                m_pArray->addObject(m_pCurDict);
            }
            else if (SAX_DICT == preState)
            {
                // add the dictionary into the pre dictionary
                CCAssert(! m_tDictStack.empty(), "The state is wrong!");
                CCDictionary<std::string, CCObject*>* pPreDict = m_tDictStack.top();
                pPreDict->setObject(m_pCurDict, m_sCurKey);
            }

			m_pCurDict->release();

            // record the dict state
            m_tStateStack.push(m_tState);
            m_tDictStack.push(m_pCurDict);
        }
        else if(sName == "key")
        {
            m_tState = SAX_KEY;
        }
        else if(sName == "integer")
        {
            m_tState = SAX_INT;
        }
        else if(sName == "real")
        {
            m_tState = SAX_REAL;
        }
        else if(sName == "string")
        {
            m_tState = SAX_STRING;
        }
        else if (sName == "array")
        {
            m_tState = SAX_ARRAY;
            m_pArray = new CCMutableArray<CCObject*>();
            if (m_eResultType == SAX_RESULT_ARRAY && m_pRootArray == NULL)
            {
                m_pRootArray = m_pArray;
                m_pRootArray->retain();
            }
            CCSAXState preState = SAX_NONE;
            if (! m_tStateStack.empty())
            {
                preState = m_tStateStack.top();
            }

            //CCSAXState preState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
            if (preState == SAX_DICT)
            {
                m_pCurDict->setObject(m_pArray, m_sCurKey);
            }
            else if (preState == SAX_ARRAY)
            {
                CCAssert(! m_tArrayStack.empty(), "The state is worng!");
                CCMutableArray<CCObject*>* pPreArray = m_tArrayStack.top();
                pPreArray->addObject(m_pArray);
            }
            m_pArray->release();
            // record the array state
            m_tStateStack.push(m_tState);
            m_tArrayStack.push(m_pArray);
        }
        else
        {
            m_tState = SAX_NONE;
        }
    }
Пример #23
0
	~CGraphvizVisitor() 
	{
		m_clusterStack.pop();
		assert(m_clusterStack.empty());
	}
Пример #24
0
void EvalStack::exec(char chr) {
  AttributeValue a, b, c;
  switch (chr) {
  case '+':
  case '-':
  case '*':
  case '/':
  case '>':
  case '<':
  case funcMin:
  case funcMax:
  case funcTable:
    if (vals.size() < 2) return;
    b = vals.top(); vals.pop();
    a = vals.top(); vals.pop();
    vals.push(binop(a, b, chr));
    break;
  case '~':
    if (vals.size() < 1) return;
    if (vals.top().text.empty()) {
      a = vals.top(); vals.pop();
      vals.emplace(-a.max, -a.min);
    }
    break;
  case ':':
    if (vals.size() < 3) return;
    c = vals.top(); vals.pop();
    b = vals.top(); vals.pop();
    a = vals.top(); vals.pop();
    vals.push(a.max ? b : c);
    break;
  }
}
Пример #25
0
	void OnEndGraph(int kind, const std::string & id)
	{
		m_clusterStack.pop();
	}
Пример #26
0
void MenuServices::run(const std::vector<std::string> &cmd,
                       std::stack<std::unique_ptr<MenuBase>> &menuStack)
{
    if (cmd.size() > 0)
    {
        if (cmd[0] == "find")
        {
            std::vector<std::string> knownServices =
            {
                // services
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_BRIGHTNESS,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_POWER_SWITCH,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_CONNECTION_MANAGER,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_AV_TRANSPORT,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_CONTENT_DIRECTORY,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_RENDERING_CONTROL,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_SCHEDULED_RECORDING,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_WAN_IF_CONFIG,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_LAYER3_FORWARDING,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_WAN_CABLE_LINK_CONFIG,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_WAN_DSL_LINK_CONFIG,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_WAN_ETHERNET_CONFIG,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_WAN_POTS_LINK_CONFIG,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_WAN_IP_CONNECTION,
                std::string(OC_RSRVD_WELL_KNOWN_URI) +  "?rt=" + UPNP_OIC_TYPE_LAN_HOST_CONFIG

            };
            for (auto service : knownServices)
            {
                OC::OCPlatform::findResource("", service, CT_DEFAULT, onFindResourceCb);
            }

        }
        else if (cmd[0] == "list")
        {
            if (!m_avTransport.empty())
            {
                std::cout << "AV Transport Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_avTransport)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_brightness.empty())
            {
                std::cout << "Brightness Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_brightness)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_binarySwitch.empty())
            {
                std::cout << "Binary Switch Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_binarySwitch)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_connectionManager.empty())
            {
                std::cout << "Connection Manager Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_connectionManager)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_contentDirectory.empty())
            {
                std::cout << "Content Dirctory Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_contentDirectory)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_layer3Forwarding.empty())
            {
                std::cout << "Layer 3 Forwarding Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_layer3Forwarding)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_renderingControl.empty())
            {
                std::cout << "Rendering Control Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_renderingControl)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_scheduledRecording.empty())
            {
                std::cout << "Scheduled Recording Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_scheduledRecording)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_wanIfConfig.empty())
            {
                std::cout << "WAN IF Config Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_wanIfConfig)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_wanCableLinkConfig.empty())
            {
                std::cout << "WAN Cable Link Config Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_wanCableLinkConfig)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_wanDSLLinkConfig.empty())
            {
                std::cout << "WAN DSL Link Config Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_wanDSLLinkConfig)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_wanEthernetConfig.empty())
            {
                std::cout << "WAN Ethernet Config Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_wanEthernetConfig)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_wanPotsLinkConfig.empty())
            {
                std::cout << "WAN POTS Config Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_wanPotsLinkConfig)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_wanIPConnection.empty())
            {
                std::cout << "WAN IP Connection Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_wanIPConnection)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
            if (!m_lanHostConfig.empty())
            {
                std::cout << "LAN Host Config Service(s) found:" << std::endl;
                std::cout << "---------------------------------------------" << std::endl;
                for ( auto r : m_lanHostConfig)
                {
                    printResourceCompact(r);
                    std::cout << std::endl;
                }
            }
        }
        else if ("av" == cmd[0])
        {
            std::unique_ptr<MenuAVTransport> menuItem(new MenuAVTransport);
            menuItem->init(m_avTransport);
            menuStack.push(std::move(menuItem));
        }
        else if ("brightness" == cmd[0])
        {
            std::unique_ptr<MenuBrightness> menuItem(new MenuBrightness);
            menuItem->init(m_brightness);
            menuStack.push(std::move(menuItem));
        }
        else if ("switch" == cmd[0])
        {
            std::unique_ptr<MenuBinarySwitch> menuItem(new MenuBinarySwitch);
            menuItem->init(m_binarySwitch);
            menuStack.push(std::move(menuItem));
        }
        else if ("connection" == cmd[0])
        {
            std::unique_ptr<MenuConnectionManager> menuItem(new MenuConnectionManager);
            menuItem->init(m_connectionManager);
            menuStack.push(std::move(menuItem));
        }
        else if ("content" == cmd[0])
        {
            std::unique_ptr<MenuContentDirectory> menuItem(new MenuContentDirectory);
            menuItem->init(m_contentDirectory);
            menuStack.push(std::move(menuItem));
        }
        else if ("layer3" == cmd[0])
        {
            std::unique_ptr<MenuLayer3Forwarding> menuItem(new MenuLayer3Forwarding);
            menuItem->init(m_layer3Forwarding);
            menuStack.push(std::move(menuItem));
        }
        else if ("rendering" == cmd[0])
        {
            std::unique_ptr<MenuRenderingControl> menuItem(new MenuRenderingControl);
            menuItem->init(m_renderingControl);
            menuStack.push(std::move(menuItem));
        }
        else if ("recording" == cmd[0])
        {
            std::cout << "Scheduled Recording Menu not yet Implemented" << std::endl;
        }
        else if ("ifconfig" == cmd[0])
        {
            std::unique_ptr<MenuWANCommonInterface> menuItem(new MenuWANCommonInterface);
            menuItem->init(m_wanIfConfig);
            menuStack.push(std::move(menuItem));
        }
        else if ("cableconfig" == cmd[0])
        {
            std::cout << "WAN Cable Link Config Menu not yet Implemented" << std::endl;
        }
        else if ("dslconfig" == cmd[0])
        {
            std::cout << "WAN DSL Link Config Menu not yet Implemented" << std::endl;
        }
        else if ("netconfig" == cmd[0])
        {
            std::cout << "WAN Ethernet Config Menu not yet Implemented" << std::endl;
        }
        else if ("potsconfig" == cmd[0])
        {
            std::cout << "WAN POTS Config Menu not yet Implemented" << std::endl;
        }
        else if ("ipconnection" == cmd[0])
        {
            std::unique_ptr<MenuWANIpConnection> menuItem(new MenuWANIpConnection);
            menuItem->init(m_wanIPConnection);
            menuStack.push(std::move(menuItem));
        }
        else if ("lanhost" == cmd[0])
        {
            std::unique_ptr<MenuLANHostConfigManagement> menuItem(new MenuLANHostConfigManagement);
            menuItem->init(m_lanHostConfig);
            menuStack.push(std::move(menuItem));
        }
        else if ("clear" == cmd[0])
        {
            m_avTransport.clear();
            m_binarySwitch.clear();
            m_brightness.clear();
            m_connectionManager.clear();
            m_contentDirectory.clear();
            m_layer3Forwarding.clear();
            m_renderingControl.clear();
            m_scheduledRecording.clear();
            m_wanIfConfig.clear();
            print();
        }
        else if ("q" == cmd[0])
        {
            m_quit = true;
        }
        else if ("b" == cmd[0])
        {
            if (menuStack.size() <= 1)
            {
                print();
                return; //do nothing
            }
            else
            {
                menuStack.pop();
                menuStack.top()->print();
            }
        }
        else if ("h" == cmd[0])
        {
            help();
        }
        else
        {
            std::cout << "unknown command." << std::endl;
            print();
        }
    }
}
Пример #27
0
	void OnEndCluster(const std::string & id)
	{
		m_clusterStack.pop();
	}
Пример #28
0
 void PushExpValueCount(int count)
 {
     exp_value_count_.push(count);
 }
Пример #29
0
    void endElement(void *ctx, const char *name)
    {
        CC_UNUSED_PARAM(ctx);
        SAXState curState = _stateStack.empty() ? SAX_DICT : _stateStack.top();
        const std::string sName((char*)name);
        if( sName == "dict" )
        {
            _stateStack.pop();
            _dictStack.pop();
            if ( !_dictStack.empty())
            {
                _curDict = _dictStack.top();
            }
        }
        else if (sName == "array")
        {
            _stateStack.pop();
            _arrayStack.pop();
            if (! _arrayStack.empty())
            {
                _curArray = _arrayStack.top();
            }
        }
        else if (sName == "true")
        {
            if (SAX_ARRAY == curState)
            {
                _curArray->push_back(Value(true));
            }
            else if (SAX_DICT == curState)
            {
                (*_curDict)[_curKey] = Value(true);
            }
        }
        else if (sName == "false")
        {
            if (SAX_ARRAY == curState)
            {
                _curArray->push_back(Value(false));
            }
            else if (SAX_DICT == curState)
            {
                (*_curDict)[_curKey] = Value(false);
            }
        }
        else if (sName == "string" || sName == "integer" || sName == "real")
        {
            if (SAX_ARRAY == curState)
            {
                if (sName == "string")
                    _curArray->push_back(Value(_curValue));
                else if (sName == "integer")
                    _curArray->push_back(Value(atoi(_curValue.c_str())));
                else
                    _curArray->push_back(Value(atof(_curValue.c_str())));
            }
            else if (SAX_DICT == curState)
            {
                if (sName == "string")
                    (*_curDict)[_curKey] = Value(_curValue);
                else if (sName == "integer")
                    (*_curDict)[_curKey] = Value(atoi(_curValue.c_str()));
                else
                    (*_curDict)[_curKey] = Value(atof(_curValue.c_str()));
            }

            _curValue.clear();
        }

        _state = SAX_NONE;
    }
Пример #30
0
void DroneController::popAllCommands()
{
	m_mutex.lock();
	while(!m_commandStack.empty()) m_commandStack.pop();
	m_mutex.unlock();
}