request.cpp

可用该程序将avi的电影文件转化为TS流

//------------------------------------------------------------------------------
// Constructor.
//------------------------------------------------------------------------------
C_Message::C_Message(const C_Answer& cAnswer) : m_cRequest("none"),
                                                m_cAnswer(cAnswer),
                                                m_cEvent("none")
{
  m_iType = ANSWER_TYPE;
}


//------------------------------------------------------------------------------
// Constructor.
//------------------------------------------------------------------------------
C_Message::C_Message(const C_Event& cEvent) : m_cRequest("none"),
                                              m_cAnswer("none"),
                                              m_cEvent(cEvent)
{
  m_iType = EVENT_TYPE;
}


//------------------------------------------------------------------------------
// Reverse streaming (temporary)
//------------------------------------------------------------------------------
C_Message::C_Message(const C_String& strMessage) : m_cRequest("none"),
                                                   m_cAnswer("none"),
                                                   m_cEvent("none")
{
  C_StringTokenizer cTokenizer(strMessage, STRING_SEPARATOR);

  unsigned int iCount = cTokenizer.CountTokens();

  if (iCount >= 2)
  {
    C_String strType = cTokenizer.NextToken();
    if (strType == REQUEST_TYPE_STR)
    {
      // "1 CMD {ARG VALUE}xN"
      if (iCount % 2 == 0)
      {
        m_iType = REQUEST_TYPE;
        C_String strCmd = cTokenizer.NextToken();
        m_cRequest.m_strCmd = strCmd;
        while (cTokenizer.HasMoreToken())
        {
          C_String strArgName = cTokenizer.NextToken();
          C_String strArgValue = cTokenizer.NextToken();
          m_cRequest.SetArg(strArgName, strArgValue);
        }
      }
      else
      {
        // Bad request
        m_iType = INVALID_TYPE;
      }
    }
    else if (strType == ANSWER_TYPE_STR)
    {
      // "2 ANSWER"
      // ANSWER == "PROVIDER STATUS N {MESSAGES}xN M {ANSWER}xM"
      if (iCount >= 5)
      {
        m_iType = ANSWER_TYPE;
        C_Answer *pAnswer = ExtractAnswer(cTokenizer);
        if (pAnswer)
        {
          m_cAnswer = *pAnswer;
          delete pAnswer;
        }
        else
        {
          // Bad answer
          m_iType = INVALID_TYPE;
        }
      }
      else
      {
        // Bad answer
        m_iType = INVALID_TYPE;
      }
    }
    else if (strType == EVENT_TYPE_STR)
    {
      // "3 PROVIDER CODE N {PROPERTY VALUE}xN M {MESSAGE}xM"
      if (iCount >= 5)
      {
        m_iType = EVENT_TYPE;
        // get the provider
        C_String strProvider = cTokenizer.NextToken();
        m_cEvent = C_Event(strProvider);
        // get the code
        C_String strCode = cTokenizer.NextToken();
        m_cEvent.SetCode(strCode.ToInt());
        // get the properties
        C_String strPropertyCount = cTokenizer.NextToken();
        unsigned int iPropertyCount = strPropertyCount.ToInt();
        if(cTokenizer.CountTokens() >= 2 * iPropertyCount + 1)
        {
          for(unsigned int i = 0; i < iPropertyCount; i++)
          {
            C_String strName = cTokenizer.NextToken();
            C_String strValue = cTokenizer.NextToken();
//            m_cEvent.SetProperty(strName, strValue);
            printf("should read the broadcast info here instead");
          }
        }
        else
        {
          // Bad event
          m_iType = INVALID_TYPE;
        }
        // get the messages
        C_String strMessageCount = cTokenizer.NextToken();
        unsigned int iMessageCount = strPropertyCount.ToInt();
        if(cTokenizer.CountTokens() == iMessageCount)
        {
          for(unsigned int i = 0; i < iMessageCount; i++)
          {
            C_String strMessage = cTokenizer.NextToken();
            m_cEvent.AddMessage(strMessage);
          }
        }
        else
        {
          // Bad event
          m_iType = INVALID_TYPE;
        }
      }
      else
      {
        // Bad event
        m_iType = INVALID_TYPE;
      }
    }
    else
    {
      // Bad Type
      m_iType = INVALID_TYPE;
    }
  }
  else
  {
    // Bad message
    m_iType = INVALID_TYPE;
  }

  ASSERT(m_iType);
}

//------------------------------------------------------------------------------
// Streaming (temporary)
//------------------------------------------------------------------------------
C_String C_Message::GetString()
{
  ASSERT(m_iType != INVALID_TYPE)

  C_String strMessage(m_iType);

  if (m_iType == REQUEST_TYPE)
  {
    // "1 CMD {ARG VALUE}xN"
    strMessage += C_String(STRING_SEPARATOR) + m_cRequest.m_strCmd;
    C_HashTableIterator<C_String, C_String> cIterator =
                                      m_cRequest.m_cArgs.CreateIterator();
    while (cIterator.HasNext())
    {
      C_HashTableNode<C_String, C_String> *pNode = cIterator.GetNext();
      strMessage += C_String(STRING_SEPARATOR) + pNode->GetKey() +
                    STRING_SEPARATOR + *pNode->GetValue();
    }
  }
  else if(m_iType == ANSWER_TYPE)
  {
    // "2 ANSWER"
    // ANSWER == "PROVIDER STATUS N {MESSAGES}xN M {ANSWER}xM"
    strMessage += C_String(STRING_SEPARATOR) + AnswerToString(m_cAnswer);
  }
  else //if (m_iType == EVENT_TYPE)
  {
    // "3 PROVIDER CODE N {PROPERTY VALUE}xN M {MESSAGE}xM"
    strMessage += C_String(STRING_SEPARATOR) + m_cEvent.m_strProvider +
                  STRING_SEPARATOR + m_cEvent.m_iCode;
    // add the properties
//    unsigned int iSize = m_cEvent.m_cProperties.Size();
//    strMessage += C_String(STRING_SEPARATOR) + iSize;
//    C_HashTableIterator<C_String, C_String> cIterator =
//                              m_cEvent.m_cProperties.CreateIterator();
//    while(cIterator.HasNext())
//    {
//      C_HashTableNode<C_String, C_String>* pNode = cIterator.GetNext();
//      strMessage += C_String(STRING_SEPARATOR) + pNode->GetKey() +
//                    STRING_SEPARATOR + *pNode->GetValue();
//    }
    printf("Should dump the C_Broadcast* here instead");

    // add the messages
    unsigned int iSize = m_cEvent.m_cMessages.Size();
    strMessage += C_String(STRING_SEPARATOR) + iSize;
    for(unsigned int i = 0; i < iSize; i++)
      strMessage += C_String(STRING_SEPARATOR) + m_cEvent.m_cMessages[i];
  }

  return strMessage;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer* C_Message::ExtractAnswer(C_StringTokenizer &cTokenizer)
{
  // ANSWER == "PROVIDER STATUS N {MESSAGES}xN M {ANSWER}xM"
  C_Answer *pAnswer = NULL;

  unsigned int iCount = cTokenizer.CountTokens();

  if (iCount >= 4)
  {
    C_String strProvider = cTokenizer.NextToken();
    pAnswer = new C_Answer(strProvider);
    C_String strStatus = cTokenizer.NextToken();
    pAnswer->SetStatus(strStatus.ToInt());
    C_String strMessageCount = cTokenizer.NextToken();
    unsigned int iMessageCount = strMessageCount.ToInt();
    if (iMessageCount >= 0)
    {
      for (unsigned int i = 0; i < iMessageCount; i++)
      {
        if (cTokenizer.HasMoreToken())
        {
          C_String strMsg = cTokenizer.NextToken();
          pAnswer->AddMessage(strMsg);
        }
        else
        {
          // Bad answer
          delete pAnswer;
          pAnswer = NULL;
          break;
        }
      }
    }
    if (pAnswer)
    {
      C_String strAnswerCount = cTokenizer.NextToken();
      unsigned int iAnswerCount = strAnswerCount.ToInt();
      if (iAnswerCount >= 0)
      {
        for (unsigned int j = 0; j < iAnswerCount; j++)
        {
          C_Answer *pSubAnswer = ExtractAnswer(cTokenizer);
          if (pSubAnswer)
          {
            pAnswer->Add(*pSubAnswer);
          }
          else
          {
            // Bad answer
            delete pAnswer;
            pAnswer = NULL;
            break;
          }
        }
      }
      else
      {
        // Bad answer
        delete pAnswer;
        pAnswer = NULL;
      }
    }
    else
    {
      // Bad answer
      delete pAnswer;
      pAnswer = NULL;
    }
  }

  return pAnswer;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_String C_Message::AnswerToString(C_Answer &cAnswer)
{
  C_String str(cAnswer.m_strProvider);

  str += C_String(" ") + cAnswer.m_cMessages.Size();

  C_ListIterator<C_String> cIterator1 = cAnswer.m_cMessages.CreateIterator();
  while (cIterator1.HasNext())
  {
    str += " " + *cIterator1.GetNext();
  }

  str += C_String(" ") + cAnswer.m_cAnswerList.Size();

  C_ListIterator<C_Answer> cIterator2 = cAnswer.m_cAnswerList.CreateIterator();
  while (cIterator2.HasNext())
  {
    str += " " + AnswerToString(*cIterator2.GetNext());
  }

  return str;
}