Please report new issues athttps://github.com/DOCGroup
Not a bug, but a "hole" in the implementation. When using the TAO Naming Service in either flat-file or redundant mode TAO_Storable_Naming_Context::list() throws a CORBA::NO_IMPLEMENT exception in case the number of child entries exceeds the chunk size requested (how_many). In other words, list() never returns a binding list iterator. A bit of history. The flat-file implementation (-u) is a subset of the redundant naming service implementation (-r). The difference is that the flat-file implementation does not need the locking the redundant implementation needs. The phenomon in flat-file is a side effect left over from the redundant implementation. The naming service is an idempotent server, that is, it is a server that retains no state information for its client interactions, every client request stands alone and any request (that doesn't change the data stored) can be repeated, that is, there is no "conversation" between client and server. The redundant server implementation depends on this property, since there is no way to know which particular redundant server will service each request. The common implementation is to round-robin the requests. The implementation of the iterator though is not idempotent, and does depend on the client reaching the same server on each subsequent call. That is, there is a conversation. Thus, the iterator was disallowed in the redundant implementation and it carried over into the flat-file as well. The best way to handle this is to be willing to accept a very large return and pass a very large number as the how_many argument to list. In which case, no iterator is needed. However, it would be possible to implement the iterator for the flat-file case using the existing kind of iterator, but a better choice would be a different kind of list method that could retain the idempotency of the the naming service. This new iterator would be manifested in a new method to the Naming Service, for example, call it list_from void list_from ( in unsigned long starting_pos, in unsigned long how_many_allowed, out BindingList bl, out unsigned long how_many_left ); // Returns at most the requested number of bindings <how_many_allowed> // in <bl>. <how_many_returned is the actual number of binding // returned. <how_many_left> is the number of bindings remaining. // If the naming context contains additional bindings, // they are returned on subsequent calls. // // This can be used to iterate through a complete list of bindings: // CosNaming::BindingList_var bl; // for ( CORBA::ULong sp=0; // ctx->list_from(sp, 100, bl.out(), xx); // sp += bl->length() // ) // { // for(i=0; i<bl->length(); i++) // do with bl // list_from would be a TAO-specific extension.