C++ AOutputBuffer类代码示例

void AXmlElement::emitPath(AOutputBuffer& target) const
{
  if (mp_Parent)
    mp_Parent->emitPath(target);

  target.append(AConstant::ASTRING_SLASH);
  target.append(m_Name);
}

 /*!
 AEmittable
 */
 void emit(AOutputBuffer& target) const
 {
   target.append('{');
   target.append(AString::fromPointer(m_Pointer));
   if (m_Ownership)
     target.append(";owned",6);
   target.append('}');
 }

void ATextGenerator::generateRandomWord(AOutputBuffer& target, size_t len /* = 0x1 */)
{
  if (len < 1)
    return;

  //a_Lead with consonant
  --len;
  AString str, strLast("-", 1);
  generateRandomString(str, 1, AConstant::CHARSET_LOWERCASE_CONSONANTS);
  str.makeUpper();
  target.append(str);

  bool boolConsonant = false;
  while (len > 0)
  {
    if (boolConsonant)
    {
      //a_Add a consonant    
      do
      {
        str.clear();
        generateRandomString(str, 1, AConstant::CHARSET_LOWERCASE_CONSONANTS);
      }
      while(str.at(0) == strLast.at(0) && ARandomNumberGenerator::get().nextU1() > 220);

      target.append(str);
      --len;
      strLast = str;
      boolConsonant = false;
    }
    else
    {
      //a_Add a vowel
      int twice = 0;
      do
      {
        do
        {
          str.clear();
          generateRandomString(str, 1, AConstant::CHARSET_LOWERCASE_VOWELS);
        }
        while(str.at(0) == strLast.at(0) && ARandomNumberGenerator::get().nextU1() > 130);

        target.append(str);
        --len;
        strLast = str;
      }
      while (len > 0 && twice++ < 2 && ARandomNumberGenerator::get().nextU1() > 225);
  
      boolConsonant = true;
    }
  }
}

void ATextGenerator::generateUniqueId(AOutputBuffer& target, size_t size /* = 32 */)
{
  if (size < 16)
    ATHROW(NULL, AException::InvalidParameter);

  ARope rope;
  size_t x = ATime::getTickCount();
  rope.append((const char *)&x, sizeof(size_t));
  
  size_t bytesToAdd = size - sizeof(size_t);
  while(bytesToAdd >= 4) 
  {
    x = ARandomNumberGenerator::get(ARandomNumberGenerator::Lecuyer).nextU4();
    rope.append((const char *)&x, 4); 
    bytesToAdd -= 4; 
  }
  while(bytesToAdd > 0)
  {
    x = ARandomNumberGenerator::get(ARandomNumberGenerator::Lecuyer).nextU1();
    rope.append((const char *)&x, 1);
    --bytesToAdd;
  }

  AASSERT(NULL, !bytesToAdd);
  AString str(rope.getSize() * 2, 256);
  ATextConverter::encode64(rope, str);
  AASSERT(&str, str.getSize() >= size);
  target.append(str, size);
}

void ATextGenerator::generateRandomString(AOutputBuffer& target, size_t len, const AString& strCharSet)
{
  for (size_t i = 0x0; i < len; ++i)
  {
    target.append(strCharSet.peek(ARandomNumberGenerator::get().nextRange(strCharSet.getSize())));
  }
}

void ATemplateNodeHandler_MODEL::Node::process(ATemplateContext& context, AOutputBuffer& output)
{
  AAutoPtr<AEventVisitor::ScopedEvent> scoped;
  if (context.useEventVisitor().isLogging(AEventVisitor::EL_DEBUG))
  {
    scoped.reset(new AEventVisitor::ScopedEvent(context.useEventVisitor(), ASW("ATemplateNodeHandler_MODEL",26), m_BlockData, AEventVisitor::EL_DEBUG));
  }

  if (m_BlockData.isEmpty())
    return;

  AXmlElement *pElement = context.useModel().useRoot().findElement(m_BlockData);
  if (pElement)
  {
    //a_Found object
    pElement->emitContent(output);
  }
  else
  {
    ARope rope("<!--Unable to find element for '",32); 
    rope.append(m_BlockData);
    rope.append("'-->",4); 
    output.append(rope);
  }
}

void ATextGenerator::generateRandomData(AOutputBuffer& target, size_t len)
{
  for (size_t i = 0x0; i < len; ++i)
  {
    target.append(ARandomNumberGenerator::get().nextU1());
  }
}

void AFilename::emitPath(AOutputBuffer& target, AFilename::FTYPE ftype, bool noTrailingSlash) const
{
  char sep = '/';
  if (FTYPE_MSDOS == ftype)
    sep = '\\';

  //a_Drive
  if (m_Drive)
  {
    switch (ftype)
    {
      case FTYPE_UNIX: 
      break;

      case FTYPE_CYGWIN:
        target.append(ASW("/cygdrive/",10));
        target.append(m_Drive);
      break;
      
      default:
        if (!m_RelativePath)
        {
          target.append(m_Drive);
          target.append(':');
        }
    }
  }

  //a_Add slash is not a relative path
  if (!m_RelativePath)
    target.append(sep);
  else if (0 == m_PathNames.size())
  {
    //a_Special case, relative and no path, default to . or ./ (depends on noTailingSlash flag)
    target.append(AConstant::ASTRING_PERIOD);
    if (!noTrailingSlash)
      target.append(sep);

    return;
  }

  //a_Path
  LIST_AString::const_iterator cit = m_PathNames.begin();
  while (cit != m_PathNames.end())
  {
    target.append(*cit);
    ++cit;

    if (cit != m_PathNames.end() || !noTrailingSlash)
      target.append(sep);
  }
}

void AXmlElement::_indent(AOutputBuffer& target, int indent) const
{
  while (indent > 0)
  {
    target.append(AConstant::ASTRING_TWOSPACES);
    --indent;
  }
}

void AFilename::emitNoExt(AOutputBuffer& target, AFilename::FTYPE ftype) const
{
  emitPath(target, ftype);

  size_t pos = m_Filename.rfind('.');
  if (AConstant::npos != pos)
    m_Filename.peek(target, 0, pos);
  else
    target.append(m_Filename);
}

void AFilename::emit(
  AOutputBuffer& target, 
  AFilename::FTYPE ftype, 
  bool noTrailingSlash // = false
) const
{

  //a_Filename
  if (!m_Filename.isEmpty())
  {
    //a_Path
    emitPath(target, ftype);

    //a_Append filename
    target.append(m_Filename);
  }
  else 
  {
    //a_Check if trailing slash is not needed
    emitPath(target, ftype, noTrailingSlash);
  }
}

void AFilename::emitDrive(AOutputBuffer& target) const
{
  target.append(m_Drive);
}

void AFilename::emitFileUrl(AOutputBuffer& target) const
{
  target.append(FILE_PREFIX);
  emit(target, AFilename::FTYPE_DEFAULT);
}

void AFragmentSet::emit(AOutputBuffer& target) const
{
	target.append(m_Set.at(m_Offset));
}

void AFragmentCounter::emit(AOutputBuffer& target) const
{
	target.append(m_strOdometer);
}