no match for call to '(Sequence::const_iterator) ()'

[fsshl]

Dear c/g++ programers:

when I tried to install/build pathan 2.0beta on my g++4.5.2/linux system
at make stage, it reponse error
------------

Sequence.cpp: In member function 'Sequence Sequence::atomize(const DynamicContext*) const':
Sequence.cpp:217:26: error: no match for call to '(Sequence::const_iterator) ()'
make[1]: *** [Sequence.o] Error 1
make[1]: Leaving directory `/home/eric/cppcookbook/ch14/download/libpathan-2.0beta/src/sequence'
make: *** [subdirs] Error 2 

---------------
Sequence.cpp is
--------------------------------------------------

#include "../config/pathan_config.h"
/*
 * Copyright (c) 2001, DecisionSoft Limited All rights reserved.
 * Please see LICENSE.TXT for more information.
 */

#include <assert.h>
#include <xercesc/dom/DOMNode.hpp>
#include <xercesc/dom/DOMNodeList.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <pathan/Sequence.hpp>

#include <pathan/SequenceType.hpp>
#include <pathan/DynamicContext.hpp>
#include "../exceptions/SequenceException.hpp"
#include <pathan/XPath2Utils.hpp>
#include "../utils/NumUtils.hpp"

#include <pathan/ATDecimalOrDerived.hpp>
#include <pathan/ATBooleanOrDerived.hpp>
#include <pathan/ATFloatOrDerived.hpp>
#include <pathan/ATDoubleOrDerived.hpp>
#include <pathan/Node.hpp>

#include <pathan/Collation.hpp>

Sequence::Sequence(XPath2MemoryManager* memMgr)
  : _itemList(PathanAllocator<const Item*>(memMgr)),
    _memMgr(memMgr)
{
}

Sequence::~Sequence()
{
	//no-op
}

Sequence::Sequence(const Item* item, XPath2MemoryManager* memMgr)
  : _itemList(1, item, PathanAllocator<const Item*>(memMgr)),
    _memMgr(memMgr)
{
}

Sequence::Sequence(const Sequence & s)
  : _itemList(s._itemList),
    _memMgr(s._memMgr)
{
}

Sequence::Sequence(const Sequence &s, XPath2MemoryManager* memMgr)
  : _itemList(PathanAllocator<const Item*>(memMgr)),
    _memMgr(memMgr)
{
  joinSequence(s);
}

Sequence::Sequence(unsigned int n, XPath2MemoryManager* memMgr)
  : _itemList(PathanAllocator<const Item*>(memMgr)),
    _memMgr(memMgr)
{
    _itemList.reserve(n);
}

Sequence & Sequence::operator=(const Sequence & s) {
	if( this != &s ) { // no self-assignment
	  _itemList = s._itemList;
	}
	return *this;
}

Sequence::Sequence(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList *domList, XPath2MemoryManager* memMgr)
  : _itemList(PathanAllocator<const Item*>(memMgr)),
    _memMgr(memMgr)
{
  unsigned int listSize=domList->getLength();
  _itemList.reserve(listSize);
  for(unsigned int i = 0; i < listSize; i++) {
    _itemList.push_back(memMgr->createNode(domList->item(i)));
  }

}

void Sequence::addItemFront(const Item* item)
{
  //This is a hack since the redhat 6.2 deque warns with push_front
  _itemList.insert(_itemList.begin(), item);
}

// returns the first item in the Sequence, or null if it is empty
const Item* Sequence::first() const
{
  assert(!isEmpty());  // should not be asking for elements if the list is empty
  return _itemList[0];
}

// returns the second item in the Sequence, or null if it is empty
const Item* Sequence::second() const
{
  assert(!isEmpty());  // should not be asking for elements if the list is empty
  return _itemList[1];
}

// might return NULL
const Item* Sequence::item(unsigned int index) const
{
  return _itemList[index];
}

const Item* Sequence::item(const ATDecimalOrDerived* index) const
{
  if(index->isNegative()) {
    DSLthrow(SequenceException,X("Sequence:item"),X("Index less than zero"));
  }
  return item(NumUtils::MAPMtoInt(index->asMAPM()));
}

void Sequence::clear(void) {
  _itemList.clear();
}

Sequence::iterator Sequence::begin(void)
{
  return _itemList.begin();
}

Sequence::iterator Sequence::end(void)
{
  return _itemList.end();
}

Sequence::const_iterator Sequence::begin(void) const
{
  return _itemList.begin();
}

Sequence::const_iterator Sequence::end(void) const
{
  return _itemList.end();
}

Sequence::reverse_iterator Sequence::rbegin(void)
{
  return _itemList.rbegin();
}

Sequence::reverse_iterator Sequence::rend(void)
{
  return _itemList.rend();
}

Sequence::const_reverse_iterator Sequence::rbegin(void) const
{
  return _itemList.rbegin();
}

Sequence::const_reverse_iterator Sequence::rend(void) const
{
  return _itemList.rend();
}

unsigned int Sequence::getLength(void) const
{
  return _itemList.size();
}

void Sequence::addItem(const Item* item) {
	_itemList.push_back(item);
}

void Sequence::joinSequence(const Sequence & s) {
	_itemList.insert(_itemList.end(),s._itemList.begin(),s._itemList.end());
}

bool Sequence::isEmpty() const {
	return _itemList.empty();
}

bool compareFn(const Item* first, const Item* second)
{
	return ((const Node*)first)->lessThan((const Node*)second);
}

void Sequence::sortIntoDocumentOrder()
{
  std::sort(_itemList.begin(), _itemList.end(), compareFn);
}

struct CollationCompare {
  CollationCompare(const Collation *collation, const DynamicContext *context)
    : _collation(collation), _context(context) {}

  bool operator()(const Item* arg1, const Item* arg2) const {
    const XMLCh* s1 = arg1->asString(_context);
    const XMLCh* s2 = arg2->asString(_context);
    return (_collation->compare(s1,s2) == -1);
  }

  const Collation *_collation;
  const DynamicContext *_context;
};

void Sequence::sortWithCollation(const Collation *collation, const DynamicContext *context)
{
  std::sort(_itemList.begin(), _itemList.end(), CollationCompare(collation, context));
}

Sequence Sequence::atomize(const DynamicContext* context) const {

  // for $item in (Expr) return
  //   typeswitch ($item)
  //     case $value as atomic value return $value
  //     default $node return fn:data($node)

  Sequence result(context->getMemoryManager());

  const_iterator end(end());
  for(const_iterator i = begin(); i != end; ++i) 
  {
	  if((*i)->isNode())
		  result.joinSequence(((const Node*)(*i))->dmTypedValue(context));
	  else
		  result.addItem(*i);
  }
  return result;
}

Sequence Sequence::castAs(const SequenceType* sequenceType, DynamicContext* context) const {
	return sequenceType->castAsFunction(*this, context);
}

const XMLCh* Sequence::castAsSingleString(DynamicContext* context) const {
	static SequenceType stringType(XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgURI_SCHEMAFORSCHEMA, 
                                   XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgDT_STRING);
	Sequence singleString = castAs(&stringType, context);
	return singleString.first()->asString(context);
}

bool Sequence::getEffectiveBooleanValue(const DynamicContext* context) const
{
  // From $ 15.1.4 of the F&O specs:
  // The effective boolean value of an operand is defined as follows:
  //
  // If $arg is the empty sequence, returns false.

  if(isEmpty()) {
    return false;
  }

  // If $arg contains a single atomic value, then the function returns false if $arg is:
  if(getLength()==1 && first()->isAtomicValue()) {
    const AnyAtomicType* arg1 = (const AnyAtomicType*)first();
    // The singleton xs:boolean value false.
    if(arg1->getPrimitiveTypeIndex() == AnyAtomicType::BOOLEAN && ((const ATBooleanOrDerived*)arg1)->isFalse())
      return false;

    // The singleton value "" (zero-length string) of type xs:string or xdt:untypedAtomic.
    if((arg1->getPrimitiveTypeIndex() == AnyAtomicType::STRING || arg1->getPrimitiveTypeIndex() == AnyAtomicType::UNTYPED_ATOMIC) &&
       XERCES_CPP_NAMESPACE_QUALIFIER XMLString::equals(arg1->asString(context), XERCES_CPP_NAMESPACE_QUALIFIER XMLUni::fgZeroLenString))
      return false;

    // A singleton numeric value that is numerically equal to zero.
    if(arg1->isNumericValue()) {
      const Numeric* num1 = (const Numeric*)arg1;
      if(num1->isZero())
        return false;

      // The singleton xs:float or xs:double value NaN.
      if(num1->getPrimitiveTypeIndex() == AnyAtomicType::FLOAT && ((const ATFloatOrDerived*)num1)->isNaN())
        return false;

      if(num1->getPrimitiveTypeIndex() == AnyAtomicType::DOUBLE && ((const ATDoubleOrDerived*)num1)->isNaN())
        return false;
    }
  }

  // In all other cases, returns true.
  return true;
}

please help to fix it, thanks a lot in advance, Eric

[hamsterman]

I think this is due to name duplication on line const_iterator end(end());. Try changing the first 'end' to something (don't forget to make the same change on the next line too) OR removing it altogether and adding () to the 'end' on the next line.

[jsmith]

That's half the problem. The other half is that the declaration is ambiguous thanks to C++'s roots in C. It is called "C++ most vexing parse" (google it for more details).

To fix, you need to use =:

const_iterator e = end();