asn1.cxx

asn格式文件的编译器

    choice.reset(obj);
    choiceID= id;   
    return obj;
}

bool CHOICE::do_accept(Visitor& visitor)
{
	return visitor.visit(*this);
}

bool CHOICE::do_accept(ConstVisitor& visitor) const
{
	return visitor.visit(*this);
}


void CHOICE::swap(CHOICE& other)
{
  assert(info_ == other.info_);
    AbstractData* tmp = other.choice.release();
	other.choice.reset(choice.release());
	choice.reset(tmp);
	std::swap(choiceID, other.choiceID);
}

int CHOICE::do_compare(const AbstractData& other) const
{
	const CHOICE& that = *boost::polymorphic_downcast<const CHOICE*>(&other);
	if (choiceID >= 0 && choiceID == that.choiceID)
		return choice->compare(*that.choice);
	return choiceID - that.choiceID;
}

AbstractData* CHOICE::do_clone() const
{
    return new CHOICE(*this);
}
    
bool CHOICE::createSelection()
{
    if (choiceID >= 0 && static_cast<unsigned>(choiceID) < info()->totalChoices )
    {
        const AbstractData::InfoType* selectionInfo = 
			static_cast<const AbstractData::InfoType*>(info()->selectionInfos[choiceID]);
        
        if (selectionInfo)
        {
            choice.reset(selectionInfo->create(selectionInfo));
            return true;
        }
    }
    choiceID = unknownSelection_;
    choice.reset();
    return false;
}


///////////////////////////////////////////////////////////////////////
SEQUENCE::FieldVector::~FieldVector()
{
	iterator it = begin(), last = end();
	for (; it != last; ++it)
		delete *it;
	clear();
}

SEQUENCE::FieldVector::FieldVector(const SEQUENCE::FieldVector& other)
{
	const_iterator it = other.begin(), last = other.end();
	reserve(other.size());
	for (; it != last; ++it)
	{
		push_back( *it ? (*it)->clone() : NULL);
	}
}

void SEQUENCE::BitMap::resize(unsigned nBits)
{
    bitData.resize((nBits+7)/8);
    totalBits = nBits;
}

bool SEQUENCE::BitMap::operator [] (unsigned bit) const 	
{	
    if (bit < totalBits)
        return (bitData[bit>>3] & (1 << (7 - (bit&7)))) != 0;
    return false;
}

void SEQUENCE::BitMap::set(unsigned bit)
{
    if (bit < totalBits)
        bitData[(unsigned)(bit>>3)] |= 1 << (7 - (bit&7));
}

void SEQUENCE::BitMap::clear(unsigned bit)
{
    if (bit < totalBits)
        bitData[(unsigned)(bit>>3)] &= ~(1 << (7 - (bit&7)));
}      

inline void SEQUENCE::BitMap::swap(BitMap& other)
{
    bitData.swap(other.bitData);
    std::swap(totalBits, other.totalBits);
}


const unsigned SEQUENCE::defaultTag =0;

AbstractData* SEQUENCE::create(const void* info)
{
	return new SEQUENCE(info);
}

SEQUENCE::SEQUENCE(const void* information)
: AbstractData(information)
{
	unsigned nBaseFields = info()->numFields;
	int nExtensions = info()->knownExtensions;
    unsigned i;
    fields.resize(nBaseFields+nExtensions);
    optionMap.resize(info()->numOptional);
    for (i = 0; i < nBaseFields; ++i)
		if (info()->ids[i]  == -1 )
			fields[i] = AbstractData::create(info()->fieldInfos[i]);

	if (info()->nonOptionalExtensions)
	{
		extensionMap.bitData.assign(info()->nonOptionalExtensions,
			info()->nonOptionalExtensions + (nExtensions+7/8));
		extensionMap.totalBits = nExtensions;
	}

	for (i = 0; i < extensionMap.size(); ++i)
		if (extensionMap[i]) 
			fields[i+nBaseFields] =	AbstractData::create(info()->fieldInfos[i+nBaseFields]);

}


SEQUENCE::SEQUENCE(const SEQUENCE & other)
: AbstractData(other),
    fields(other.fields),
	optionMap(other.optionMap),
	extensionMap(other.extensionMap)
{	
}



SEQUENCE::~SEQUENCE()
{
}



SEQUENCE & SEQUENCE::operator=(const SEQUENCE & other)
{
  assert(info_ == other.info_ );

  FieldVector temp_fields(other.fields);
  BitMap temp_optionalMap(other.optionMap);
  BitMap temp_extensionMap(other.extensionMap);

  fields.swap(temp_fields);
  optionMap.swap(temp_optionalMap);
  extensionMap.swap(temp_extensionMap);

  return *this;
}


bool SEQUENCE::hasOptionalField(unsigned opt) const
{
  if (opt < (unsigned)optionMap.size())
    return optionMap[opt];
  else
    return extensionMap[opt - optionMap.size()];
}


void SEQUENCE::includeOptionalField(unsigned opt, unsigned pos)
{
  if (opt < (unsigned)optionMap.size())
    optionMap.set(opt);
  else {
    assert(extendable());
    opt -= optionMap.size();
    if (opt >= (unsigned)extensionMap.size())
      extensionMap.resize(opt+1);
    extensionMap.set(opt);
  }
  if (fields[pos] == NULL)
	fields[pos] = AbstractData::create(info()->fieldInfos[pos]);
}


void SEQUENCE::removeOptionalField(unsigned opt)
{
  if (opt < (unsigned)optionMap.size())
    optionMap.clear(opt);
  else {
    assert(extendable());
    opt -= optionMap.size();
    extensionMap.clear(opt);
  }
}

bool SEQUENCE::do_accept(Visitor& visitor)
{
    return visitor.visit(*this);
}

bool SEQUENCE::do_accept(ConstVisitor& visitor) const
{
    return visitor.visit(*this);
}


AbstractData * SEQUENCE::do_clone() const
{
  return new SEQUENCE(*this);
}

void SEQUENCE::swap(SEQUENCE& other)
{
  fields.swap(other.fields);
  optionMap.swap(other.optionMap);
  extensionMap.swap(other.extensionMap);
}

int SEQUENCE::do_compare(const AbstractData& other) const
{
	const SEQUENCE& that = *boost::polymorphic_downcast<const SEQUENCE*>(&other);
	assert(info_ == that.info_);

    int lastOptionalId = -1, result;
    unsigned i;
    for (i = 0; i < info()->numFields ; ++i)
	{
		int id = info()->ids[i];
		if (id == mandatory_  || (hasOptionalField(id) && that.hasOptionalField(id)) )
			result = fields[i]->compare(*that.fields[i]);
		else 
			result = hasOptionalField(id) - that.hasOptionalField(id);

		if (result != 0) return result;
		lastOptionalId = ( id != mandatory_ ? id : lastOptionalId);
	}
	
	for (; i < fields.size(); ++i)
	{
		if (hasOptionalField(++lastOptionalId) && that.hasOptionalField(lastOptionalId))
			result = fields[i]->compare(*that.fields[i]);
		else
			result = hasOptionalField(lastOptionalId) - that.hasOptionalField(lastOptionalId);
	}
	return result;

}

///////////////////////////////////////////////////////


SEQUENCE_OF_Base::SEQUENCE_OF_Base(const void* info)
: ConstrainedObject(info)
{
}



SEQUENCE_OF_Base::SEQUENCE_OF_Base(const SEQUENCE_OF_Base & other)
  : ConstrainedObject(other)
{
	Container::const_iterator first = other.container.begin(), last = other.container.end();
    container.reserve(other.container.size());
	for (; first != last; ++ first)
		container.push_back( (*first)->clone());
}


SEQUENCE_OF_Base & SEQUENCE_OF_Base::operator=(const SEQUENCE_OF_Base & other)
{
    Container temp;
    Container::const_iterator first = other.container.begin(), last = other.container.end();
    temp.reserve(other.container.size());
    for (; first != last; ++ first)
        temp.push_back( (*first)->clone());
    temp.swap(container);
    return *this;
}

AbstractData* SEQUENCE_OF_Base::do_clone() const
{
    return new SEQUENCE_OF_Base(*this);
}

bool SEQUENCE_OF_Base::do_accept(Visitor& visitor)
{
	return visitor.visit(*this);
}

bool SEQUENCE_OF_Base::do_accept(ConstVisitor& visitor) const
{
	return visitor.visit(*this);
}


void SEQUENCE_OF_Base::clear()
{
  Container::const_iterator first = container.begin(), last = container.end();
  for (;first != last; ++first)
	  delete *first;
  container.clear();
}

int SEQUENCE_OF_Base::do_compare(const AbstractData& other) const
{
  const SEQUENCE_OF_Base& that = *boost::polymorphic_downcast<const SEQUENCE_OF_Base*>(&other);
  Container::const_iterator first1 = container.begin(), last1 = container.end();
  Container::const_iterator first2 = that.container.begin(), last2 = that.container.end();
  for (; first1 != last1 && first2 != last2; ++first1, ++first2)
  {
	  int r = (*first1)->compare(*(*first2));
	  if (r != 0)
		  return r;
  }
  return container.size() - that.container.size();	  
}

void SEQUENCE_OF_Base::insert(iterator position, SEQUENCE_OF_Base::Container::size_type n, const AbstractData& x)	
{
        SEQUENCE_OF_Base::Container::difference_type dist = std::distance(container.begin(), position);
        reserve(size()+ n);
        std::generate_n(std::inserter(container, container.begin() + dist), n, create_from0(x));
}

void SEQUENCE_OF_Base::insert(iterator position, const_iterator first, const_iterator last)
{
        SEQUENCE_OF_Base::Container::difference_type dist = std::distance(container.begin(), position);
        reserve(size()+ std::distance(first, last));
		std::transform(first, last, std::inserter(container, container.begin() + dist), create_from_ptr());
}

AbstractData* SEQUENCE_OF_Base::create(const void* info)
{
    return new SEQUENCE_OF_Base(info);
}

void SEQUENCE_OF_Base::resize(Container::size_type sz)
{
    if (sz < size())
    {
        iterator i = begin()+sz, last = end();
        for (; i != last; ++i)
            delete *i;
        container.resize(sz); 
    } 
    else  
    {
        container.reserve(sz);
        for (unsigned i = size(); i < sz; ++i)
            container.push_back(createElement());
    }
}

void SEQUENCE_OF_Base::erase(iterator first, iterator last)
{
    iterator f = first;
    for (;f != last; ++f)
        delete *f;
    container.erase(first, last);
}

//////////////////////////////////////////////////////

const OpenData::InfoType OpenData::theInfo = {
    OpenData::create,
    0
};




OpenData::OpenData(const OpenData& that)
: AbstractData(that)
, data(that.has_data() ? that.get_data().clone() : NULL)
, buf(that.has_buf() ? new OpenBuf(that.get_buf()) : NULL )
{}

AbstractData* OpenData::create(const void* info)
{
    return new OpenData(info);
}


void OpenData::swap(OpenData& other)	
{
	AbstractData* tmpData = data.release();
	data.reset(other.data.release());
	other.data.reset(tmpData);

	OpenBuf* tmpBuf = buf.release();
	buf.reset(other.buf.release());
	other.buf.reset(tmpBuf);
}

bool OpenData::do_accept(Visitor& visitor)
{
	return visitor.visit(*this);
}

bool OpenData::do_accept(ConstVisitor& visitor) const
{
	return visitor.visit(*this);
}


int OpenData::do_compare(const AbstractData& other) const
{
	const OpenData& that = *boost::polymorphic_downcast<const OpenData*>(&other);
	if (has_data() && that.has_data())
		return get_data().compare(that.get_data());
	if (has_buf() && that.has_buf())
		return lexicographic_compare_bytes(&(*get_buf().begin()), &(*get_buf().end()),
			&(*that.get_buf().begin()), &(*that.get_buf().end()));
	if (isEmpty() && that.isEmpty())
		return 0;
	return has_data() ? 1 : -1;
}

AbstractData* OpenData::do_clone() const 
{
    return new OpenData(*this);
}

/////////////////////////////////////////////////////////

bool TypeConstrainedOpenData::do_accept(Visitor& v)
{
    return v.visit(*this);
}

AbstractData* TypeConstrainedOpenData::create(const void* info)
{
    return new TypeConstrainedOpenData( 
        AbstractData::create(static_cast<const InfoType*>(info)->typeInfo), 
        info);
}


/////////////////////////////////////////////////////////

bool Visitor::visit(SEQUENCE& value) 
{ 
  VISIT_SEQ_RESULT result = preVisitExtensionRoots(value);
  if (result <= STOP)
    return result != FAIL;

  bool visitExtension = (result == CONTINUE);

  int lastOptionalId = -1;
  unsigned i;
  for (i = 0 ; i < value.info()->numFields; ++i)
  {
	  int optionalId = value.info()->ids[i];
      result = visitExtensionRoot(value, i, optionalId);
      if ( result <= STOP)
		return result != FAIL;
	  lastOptionalId = ( optionalId != -1 ? optionalId : lastOptionalId);
  }

  if (!visitExtension)
      return true;
   
  result = preVisitExtensions(value);

  if ( result !=  CONTINUE )
	return result != FAIL;

  for (; i < value.fields.size(); ++i)
  {
      result = visitKnownExtension(value, i, ++lastOptionalId);
      if ( result !=  CONTINUE )
          return result != FAIL;
  }

  return visitUnknownExtensions(value);
}

bool ConstVisitor::visit(const SEQUENCE& value)
{
  if (!preVisitExtensionRoots(value))
	  return false;

  unsigned i;
  int lastOptionalId = -1;	
  for (i = 0; i < value.info()->numFields ; ++i)
  {
	  int optionalId = value.info()->ids[i];
	  if (optionalId == -1 || value.hasOptionalField(optionalId))
	  {
		  assert(value.fields[i]);
		  if (!visitExtensionRoot(value, i))
			  return false;
	  }
	  lastOptionalId = ( optionalId != -1 ? optionalId : lastOptionalId);
  }

  if (value.extensionMap.size())
  {
	  assert(value.extendable());
	  
	  if (!preVisitExtensions(value))
		  return false;
	  
	  for (; i < value.fields.size(); ++i)
		  if (value.hasOptionalField(++lastOptionalId)) 
		  {
			  assert(value.fields[i]);
			  if (!visitKnownExtension(value, i))
				  return false;
		  }
  }
  return afterVisitSequence(value);
}

} // namespace ASN1