minor fixes and making compiler a bit happier

Signed-off-by: Michael Krelin <hacker@klever.net>

4 files changed, 20 insertions, 18 deletions

diff --git a/include/opkele/basic_op.h b/include/opkele/basic_op.h
index 0326508..12306dd 100644
--- a/include/opkele/basic_op.h
+++ b/include/opkele/basic_op.h
@@ -1,250 +1,252 @@
 #ifndef __OPKELE_BASIC_OP_H
 #define __OPKELE_BASIC_OP_H
 
 #include <string>
 #include <opkele/types.h>
 #include <opkele/extension.h>
 
 namespace opkele {
     using std::string;
 
     /**
      * Implementation of basic OP functionality
      */
     class basic_OP {
         public:
             /**
              * The request mode for the request being processed
              */
             mode_t mode;
             /**
              * association used in transaction. reset in case of dumb operation
              */
             assoc_t assoc;
             /**
              * true if the request is openid2 request
              */
             bool openid2;
             /**
              * The return_to RP endpoint
              */
             string return_to;
             /**
              * The realm we authenticate for
              */
             string realm;
             /**
              * Claimed identifier
              */
             string claimed_id;
             /**
              * The OP-Local identifier
              */
             string identity;
             /**
              * The invalidate handle for the reply request
              */
             string invalidate_handle;
 
+            virtual ~basic_OP() { }
+
             void reset_vars();
 
             /**
              * @name Request information access
              * Setting and retrieval of the information pertaining to the request being processed
              * @{
              */
             /**
              * Check if the RP expects us to get back to them.
              * @return true if RP supplied return_to URL
              */
             bool has_return_to() const;
             /**
              * Find out where the RP is waiting for us.
              * @return the return_to URL supplied
              * @throw no_return_to if no return_to is supplied with the request
              */
             const string& get_return_to() const;
 
             /**
              * Find out what realm we are authenticating user for
              * @return the realm
              */
             const string& get_realm() const;
 
             /**
              * Check if request is about identity
              * @return true if so
              */
             bool has_identity() const;
             /**
              * Get claimed identifier supplied with the request
              * @return claimed identifier
              * @throw non_identity if request is not about identity
              */
             const string& get_claimed_id() const;
             /**
              * Get the identity (OP-Local identifier) being confirmed
              * @return identity
              * @throw non_identity if request is not about identity
              */
             const string& get_identity() const;
 
             /**
              * Is identifier supposed to be selected on our side?
              * @return true if identity is a special identifier select URI
              */
             bool is_id_select() const;
 
             /**
              * Select the identity for identifier select request
              * @param cid claimed identifier
              * @param lid local identifier
              */
             void select_identity(const string& cid,const string& lid);
             /**
              * Set claimed identifier (for instance if it's supposed to have
              * fragment part)
              * @param cid claimed identifier
              */
             void set_claimed_id(const string& cid);
             /**
              * @}
              */
 
             /** @name OpenID operations
              * @{
              */
             /**
              * Establish association with RP
              * @param oum reply message
              * @param inm request message
              */
             basic_openid_message& associate(
                     basic_openid_message& oum,
                     const basic_openid_message& inm);
 
             /**
              * Parse the checkid_* request. The function parses input message,
              * retrieves the information needed for further processing,
              * verifies what can be verified at this stage.
              * @param inm incoming OpenID message
              * @param ext extension/chain of extensions supported
              */
             void checkid_(const basic_openid_message& inm,extension_t *ext=0);
             /**
              * Build and sign a positive assertion message
              * @param om outpu OpenID message
              * @param ext extension/chain of extensions supported
              * @return reference to om
              */
             basic_openid_message& id_res(basic_openid_message& om,
                     extension_t *ext=0);
             /**
              * Build a 'cancel' negative assertion
              * @param om output OpenID message
              * @return reference to om
              */
             basic_openid_message& cancel(basic_openid_message& om);
             /**
              * Build an 'error' reply
              * @param om output OpenID message
              * @param error a human-readable message indicating the cause
              * @param contact contact address for the server administrator (can be empty)
              * @param reference a reference token (can be empty)
              * @return reference to om
              */
             basic_openid_message& error(basic_openid_message& om,
                     const string& error,const string& contact,
                     const string& reference );
             /**
              * Build a setup_needed reply to checkid_immediate request
              * @param oum output OpenID message
              * @param inm incoming OpenID request being processed
              * @return reference to oum
              */
             basic_openid_message& setup_needed(
                     basic_openid_message& oum,const basic_openid_message& inm);
 
             /**
              * Process check_authentication request
              * @param oum output OpenID message
              * @param inm incoming request
              * @return reference to oum
              */
             basic_openid_message& check_authentication(
                     basic_openid_message& oum,const basic_openid_message& inm);
             /**
              * @}
              */
 
             /**
              * Verify return_to url. The default implementation checks whether
              * return_to URI matches the realm
              * @throw bad_realm in case of invalid realm
              * @throw bad_return_to if return_to doesn't match the realm
              * @see verify_OP::verify_return_to()
              */
             virtual void verify_return_to();
 
             /**
              * @name Global persistent store API
              * These functions are related to the associations with RPs storage
              * and retrieval and nonce management.
              * @{
              */
             /**
              * Allocate association.
              * @param type association type
              * @param kl association key length
              * @param sl true if the association is stateless
              * @return association object
              */
             virtual assoc_t alloc_assoc(const string& type,size_t kl,bool sl) = 0;
             /**
              * Retrieve valid unexpired association
              * @param handle association handle
              * @return association object
              */
             virtual assoc_t retrieve_assoc(const string& handle) = 0;
             /**
              * Allocate nonce.
              * @param nonce input-output parameter containing timestamp part of
              * the nonce on input
              * @param sl true if the nonce is
              * @return reference to nonce
              * @throw failed_lookup if no such valid unexpired association
              * could be retrieved
              */
             virtual string& alloc_nonce(string& nonce) = 0;
             /**
              * Check nonce validity
              * @param nonce nonce to check
              * @return true if nonce found and isn't yet invalidated
              */
             virtual bool check_nonce(const string& nonce) = 0;
             /**
              * Invalidate nonce
              * @param nonce nonce to check
              */
             virtual void invalidate_nonce(const string& nonce) = 0;
             /**
              * @}
              */
 
             /**
              * @name Site particulars API
              * @{
              */
             /**
              * Query the absolute URL of the op endpoint
              * @return fully qualified url of the OP endpoint
              */
             virtual const string get_op_endpoint() const = 0;
             /**
              * @}
              */
 
     };
 }
 
 #endif /* __OPKELE_BASIC_OP_H */
diff --git a/include/opkele/expat.h b/include/opkele/expat.h
index 60c41ac..3ab1630 100644
--- a/include/opkele/expat.h
+++ b/include/opkele/expat.h
@@ -1,91 +1,91 @@
 #ifndef __OPKELE_EXPAT_H
 #define __OPKELE_EXPAT_H
 
 #include <cassert>
 #include <expat.h>
 
 namespace opkele {
 
     namespace util {
 
         class expat_t {
             public:
                 XML_Parser _x;
 
                 expat_t() : _x(0) { }
                 expat_t(XML_Parser x) : _x(x) { }
                 virtual ~expat_t() throw();
 
                 expat_t& operator=(XML_Parser x);
 
                 operator const XML_Parser(void) const { return _x; }
                 operator XML_Parser(void) { return _x; }
 
                 inline bool parse(const char *s,int len,bool final=false) {
                     assert(_x);
                     return XML_Parse(_x,s,len,final);
                 }
 
-                virtual void start_element(const XML_Char *n,const XML_Char **a) { }
-                virtual void end_element(const XML_Char *n) { }
+                virtual void start_element(const XML_Char * /* n */,const XML_Char ** /* a */) { }
+                virtual void end_element(const XML_Char * /* n */) { }
                 void set_element_handler();
 
-                virtual void character_data(const XML_Char *s,int l) { }
+                virtual void character_data(const XML_Char * /* s */,int /* l */) { }
                 void set_character_data_handler();
 
-                virtual void processing_instruction(const XML_Char *t,const XML_Char *d) { }
+                virtual void processing_instruction(const XML_Char * /* t */,const XML_Char * /* d */) { }
                 void set_processing_instruction_handler();
 
-                virtual void comment(const XML_Char *d) { }
+                virtual void comment(const XML_Char * /* d */) { }
                 void set_comment_handler();
 
                 virtual void start_cdata_section() { }
                 virtual void end_cdata_section() { }
                 void set_cdata_section_handler();
 
-                virtual void default_handler(const XML_Char *s,int l) { }
+                virtual void default_handler(const XML_Char * /* s */,int /* l */) { }
                 void set_default_handler();
                 void set_default_handler_expand();
 
-                virtual void start_namespace_decl(const XML_Char *p,const XML_Char *u) { }
-                virtual void end_namespace_decl(const XML_Char *p) { }
+                virtual void start_namespace_decl(const XML_Char * /* p */,const XML_Char * /* u */) { }
+                virtual void end_namespace_decl(const XML_Char * /* p */) { }
                 void set_namespace_decl_handler();
 
                 inline enum XML_Error get_error_code() {
                     assert(_x); return XML_GetErrorCode(_x); }
                 static inline const XML_LChar *error_string(XML_Error c) {
                     return XML_ErrorString(c); }
 
                 inline long get_current_byte_index() {
                     assert(_x); return XML_GetCurrentByteIndex(_x); }
                 inline int get_current_line_number() {
                     assert(_x); return XML_GetCurrentLineNumber(_x); }
                 inline int get_current_column_number() {
                     assert(_x); return XML_GetCurrentColumnNumber(_x); }
 
                 inline void set_user_data() {
                     assert(_x); XML_SetUserData(_x,this); }
 
                 inline bool set_base(const XML_Char *b) {
                     assert(_x); return XML_SetBase(_x,b); }
                 inline const XML_Char *get_base() {
                     assert(_x); return XML_GetBase(_x); }
 
                 inline int get_specified_attribute_count() {
                     assert(_x); return XML_GetSpecifiedAttributeCount(_x); }
 
                 inline bool set_param_entity_parsing(enum XML_ParamEntityParsing c) {
                     assert(_x); return XML_SetParamEntityParsing(_x,c); }
 
                 inline static XML_Parser parser_create(const XML_Char *e=0) {
                     return XML_ParserCreate(e); }
                 inline static XML_Parser parser_create_ns(const XML_Char *e=0,XML_Char s='\t') {
                     return XML_ParserCreateNS(e,s); }
 
         };
 
     }
 
 }
 
 #endif /* __OPKELE_EXPAT_H */
diff --git a/include/opkele/iterator.h b/include/opkele/iterator.h
index 812a786..28c1c83 100644
--- a/include/opkele/iterator.h
+++ b/include/opkele/iterator.h
@@ -1,217 +1,216 @@
 #ifndef __OPKELE_ITERATOR_H
 #define __OPKELE_ITERATOR_H
 
 #include <cassert>
 #include <iterator>
 
 namespace opkele {
     namespace util {
         using std::iterator;
         using std::forward_iterator_tag;
         using std::output_iterator_tag;
 
         template <typename T>
         class basic_output_iterator_proxy_impl : public iterator<output_iterator_tag,T,void,T*,T&> {
             public:
                 virtual ~basic_output_iterator_proxy_impl() { }
 
                 virtual basic_output_iterator_proxy_impl<T>* dup() const = 0;
                 basic_output_iterator_proxy_impl<T>& operator*() { return *this; };
                 virtual basic_output_iterator_proxy_impl<T>& operator=(const T& x) = 0;
 
         };
 
         template<typename IT,typename T=typename IT::value_type>
         class output_iterator_proxy_impl : public basic_output_iterator_proxy_impl<T> {
             public:
                 IT i;
 
-                output_iterator_proxy_impl(const IT& i) : i(i) { }
+                output_iterator_proxy_impl(const IT& _i) : i(_i) { }
                 basic_output_iterator_proxy_impl<T>* dup() const {
                     return new output_iterator_proxy_impl<IT,T>(i); }
                 basic_output_iterator_proxy_impl<T>& operator=(const T& x) {
-                    (*i) = x;
-                }
+                    (*i) = x; return *this; }
         };
 
         template<typename T>
         class output_iterator_proxy : public iterator<output_iterator_tag,T,void,T*,T&> {
             public:
                 basic_output_iterator_proxy_impl<T> *I;
 
                 template<typename IT>
                     output_iterator_proxy(const IT& i)
                     : I(new output_iterator_proxy_impl<IT,T>(i)) { }
                 output_iterator_proxy(const output_iterator_proxy<T>& x)
                     : I(x.I->dup()) { }
                 ~output_iterator_proxy() { delete I; }
 
                 output_iterator_proxy& operator=(const output_iterator_proxy<T>& x) {
                     delete I; I = x.I->dup(); }
 
                 output_iterator_proxy& operator*() { return *this; }
                 output_iterator_proxy& operator=(const T& x) {
-                    (**I) = x; }
+                    (**I) = x; return *this; }
 
                 output_iterator_proxy& operator++() { return *this; }
                 output_iterator_proxy& operator++(int) { return *this; }
         };
 
         template <typename T,typename TR=T&,typename TP=T*>
         class basic_forward_iterator_proxy_impl : public iterator<forward_iterator_tag,T,void,TP,TR> {
             public:
                 virtual ~basic_forward_iterator_proxy_impl() { }
 
                 virtual basic_forward_iterator_proxy_impl<T,TR,TP>* dup() const = 0;
 
                 virtual bool operator==(const basic_forward_iterator_proxy_impl<T,TR,TP>& x) const = 0;
                 virtual bool operator!=(const basic_forward_iterator_proxy_impl<T,TR,TP>& x) const {
                     return !((*this)==x); }
                 virtual TR operator*() const = 0;
                 virtual TP operator->() const = 0;
                 virtual void advance() = 0;
         };
 
         template <typename IT>
         class forward_iterator_proxy_impl : public basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer> {
             public:
                 IT i;
 
-                forward_iterator_proxy_impl(const IT& i) : i(i) { }
+                forward_iterator_proxy_impl(const IT& _i) : i(_i) { }
 
                 virtual basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>* dup() const {
                     return new forward_iterator_proxy_impl<IT>(i); }
 
                 virtual bool operator==(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
                     return i==static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
                 virtual bool operator!=(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
                     return i!=static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
                 virtual typename IT::reference operator*() const { return *i; }
                 virtual typename IT::pointer operator->() const { return i.operator->(); }
                 virtual void advance() { ++i; }
         };
 
         template<typename T,typename TR=T&,typename TP=T*>
         class forward_iterator_proxy : public iterator<forward_iterator_tag,T,void,TP,TR> {
             public:
                 basic_forward_iterator_proxy_impl<T,TR,TP> *I;
 
                 template<typename IT>
                     forward_iterator_proxy(const IT& i)
                     : I(new forward_iterator_proxy_impl<IT>(i)) { }
                 forward_iterator_proxy(const forward_iterator_proxy<T,TR,TP>& x)
                     : I(x.I->dup()) { }
                 ~forward_iterator_proxy() { delete I; }
 
                 forward_iterator_proxy& operator=(const forward_iterator_proxy<T,TR,TP>& x) {
                     delete I; I = x.I->dup(); }
 
                 bool operator==(const forward_iterator_proxy<T,TR,TP>& x) const {
                     return (*I)==(*(x.I)); }
                 bool operator!=(const forward_iterator_proxy<T,TR,TP>& x) const {
                     return (*I)!=(*(x.I)); }
 
                 TR operator*() const {
                     return **I; }
                 TP operator->() const {
                     return I->operator->(); }
 
                 forward_iterator_proxy<T,TR,TP>& operator++() {
                     I->advance(); return *this; }
                 forward_iterator_proxy<T,TR,TP>& operator++(int) {
                     forward_iterator_proxy<T,TR,TP> rv(*this);
                     I->advance(); return rv; }
         };
 
         template<typename IT>
             class basic_filterator : public iterator<
                                           typename IT::iterator_category,
                                           typename IT::value_type,
                                           typename IT::difference_type,
                                           typename IT::pointer,
                                           typename IT::reference> {
                 public:
                     IT it;
                     IT ei;
                     bool empty;
 
                     basic_filterator() : empty(true) { }
-                    basic_filterator(const IT& bi,const IT& ei)
-                        : it(bi), ei(ei) { empty = (bi==ei); }
+                    basic_filterator(const IT& _bi,const IT& _ei)
+                        : it(_bi), ei(_ei) { empty = (it==ei); }
                     basic_filterator(const basic_filterator<IT>& x)
                         : it(x.it), ei(x.ei), empty(x.empty) { }
                     virtual ~basic_filterator() { }
 
                     bool operator==(const basic_filterator<IT>& x) const {
                         return empty?x.empty:(it==x.it); }
                     bool operator!=(const basic_filterator<IT>& x) const {
                         return empty!=x.empty || it!=x.it; }
 
                     typename IT::reference operator*() const {
                         assert(!empty);
                         return *it; }
                     typename IT::pointer operator->() const {
                         assert(!empty);
                         return it.operator->(); }
 
                     basic_filterator<IT>& operator++() {
                         bool found = false;
                         for(++it;!(it==ei || (found=is_interesting()));++it);
                         if(!found) empty=true;
                         return *this;
                     }
                     basic_filterator<IT> operator++(int) {
                         basic_filterator<IT> rv(*this);
                         ++(*this);
                         return rv;
                     }
 
                     void prepare() {
                         bool found = false;
                         for(;!(it==ei || (found=is_interesting()));++it);
                         if(!found) empty = true;
                     }
                     virtual bool is_interesting() const = 0;
             };
 
         template<typename IT,typename T=typename IT::value_type::first_type,typename TR=T&,typename TP=T*>
             class map_keys_iterator : public iterator<
                                       typename IT::iterator_category,
                                       T,void,TP,TR> {
                 public:
                     typedef map_keys_iterator<IT,T,TR,TP> self_type;
                     IT it;
                     IT ei;
                     bool empty;
 
                     map_keys_iterator() : empty(true) { }
-                    map_keys_iterator(const IT& bi,
-                            const IT& ei)
-                        : it(bi), ei(ei) { empty = (bi==ei); }
+                    map_keys_iterator(const IT& _bi,
+                            const IT& _ei)
+                        : it(_bi), ei(_ei) { empty = (it==ei); }
                     map_keys_iterator(const self_type& x)
                         : it(x.it), ei(x.ei), empty(x.empty) { }
 
                     bool operator==(const self_type& x) const {
                         return empty?x.empty:(it==x.it); }
                     bool operator!=(const self_type& x) const {
                         return empty!=x.empty || it!=x.it; }
 
                     TR operator*() const {
                         assert(!empty);
                         return it->first; }
                     TP operator->() const {
                         assert(!empty);
                         return &(it->first); }
 
                     self_type& operator++() {
                         assert(!empty);
                         empty=((++it)==ei); return *this; }
                     self_type operator++(int) {
                         self_type rv(*this);
                         ++(*this); return rv; }
             };
 
     }
 }
 
 #endif /* __OPKELE_ITERATOR_H */
diff --git a/include/opkele/types.h b/include/opkele/types.h
index 6ab51ef..a3b657d 100644
--- a/include/opkele/types.h
+++ b/include/opkele/types.h
@@ -1,229 +1,230 @@
 #ifndef __OPKELE_TYPES_H
 #define __OPKELE_TYPES_H
 
 /**
  * @file
  * @brief various types declarations
  */
 
 #include <cstring>
 #include <ostream>
 #include <vector>
 #include <string>
 #include <map>
 #include <set>
 #include <list>
 #include <opkele/iterator.h>
 #include <opkele/tr1-mem.h>
 
 namespace opkele {
     using std::vector;
     using std::string;
     using std::map;
     using std::ostream;
     using std::multimap;
     using std::set;
     using std::list;
     using std::iterator;
     using std::forward_iterator_tag;
 
     /**
      * the OpenID operation mode
      */
     typedef enum _mode_t {
         mode_unknown = 0,
         mode_associate,
         mode_checkid_immediate,
         mode_checkid_setup,
         mode_check_association
     } mode_t;
 
     /**
      * the association secret container
      */
     class secret_t : public vector<unsigned char> {
         public:
 
             /**
              * xor the secret and hmac together and encode, using base64
              * @param key_d pointer to the message digest
              * @param rv reference to the return value
              */
             void enxor_to_base64(const unsigned char *key_d,string& rv) const;
             /**
              * decode base64-encoded secret and xor it with the message digest
              * @param key_d pointer to the message digest
              * @param b64 base64-encoded secret value
              */
             void enxor_from_base64(const unsigned char *key_d,const string& b64);
             /**
              * plainly encode to base64 representation
              * @param rv reference to the return value
              */
             void to_base64(string& rv) const;
             /**
              * decode cleartext secret from base64
              * @param b64 base64-encoded representation of the secret value
              */
             void from_base64(const string& b64);
     };
 
     /**
      * Interface to the association.
      */
     class association_t {
         public:
 
             virtual ~association_t() { }
 
             /**
              * retrieve the server with which association was established.
              * @return server name
              */
             virtual string server() const = 0;
             /**
              * retrieve the association handle.
              * @return handle
              */
             virtual string handle() const = 0;
             /**
              * retrieve the association type.
              * @return association type
              */
             virtual string assoc_type() const = 0;
             /**
              * retrieve the association secret.
              * @return association secret
              */
             virtual secret_t secret() const = 0; 
             /**
              * retrieve the number of seconds the association expires in.
              * @return seconds till expiration
              */
             virtual int expires_in() const = 0;
             /**
              * check whether the association is stateless.
              * @return true if stateless
              */
             virtual bool stateless() const = 0;
             /**
              * check whether the association is expired.
              * @return true if expired
              */
             virtual bool is_expired() const = 0;
     };
 
     /**
      * the shared_ptr<> for association_t object type
      */
     typedef tr1mem::shared_ptr<association_t> assoc_t;
 
     class basic_openid_message {
         public:
             typedef list<string> fields_t;
             typedef util::forward_iterator_proxy<
                 string,const string&,const string*
                 > fields_iterator;
 
             basic_openid_message() { }
+            virtual ~basic_openid_message() { }
             basic_openid_message(const basic_openid_message& x);
             void copy_to(basic_openid_message& x) const;
 
             virtual bool has_field(const string& n) const = 0;
             virtual const string& get_field(const string& n) const = 0;
 
             virtual bool has_ns(const string& uri) const;
             virtual string get_ns(const string& uri) const;
 
             virtual fields_iterator fields_begin() const = 0;
             virtual fields_iterator fields_end() const = 0;
 
             virtual string append_query(const string& url) const;
             virtual string query_string() const;
 
 
             virtual void reset_fields();
             virtual void set_field(const string& n,const string& v);
             virtual void reset_field(const string& n);
 
             virtual void from_keyvalues(const string& kv);
             virtual void to_keyvalues(ostream& o) const;
 
             virtual void to_htmlhiddens(ostream& o) const;
 
             void add_to_signed(const string& fields);
             string find_ns(const string& uri,const char *pfx) const;
             string allocate_ns(const string& uri,const char *pfx);
     };
 
     class openid_message_t : public basic_openid_message, public map<string,string> {
         public:
             openid_message_t() { }
             openid_message_t(const basic_openid_message& x)
                 : basic_openid_message(x) { }
 
             void copy_to(basic_openid_message& x) const;
 
             bool has_field(const string& n) const;
             const string& get_field(const string& n) const;
             virtual fields_iterator fields_begin() const;
             virtual fields_iterator fields_end() const;
 
             void reset_fields();
             void set_field(const string& n,const string& v);
             void reset_field(const string& n);
     };
 
     /**
      * request/response parameters map
      */
     class params_t : public openid_message_t {
         public:
 
             /**
              * check whether the parameter is present.
              * @param n the parameter name
              * @return true if yes
              */
             bool has_param(const string& n) const {
                 return has_field(n); }
             /**
              * retrieve the parameter (const version)
              * @param n the parameter name
              * @return the parameter value
              * @throw failed_lookup if there is no such parameter
              */
             const string& get_param(const string& n) const {
                 return get_field(n); }
 
             /**
              * parse the OpenID key/value data.
              * @param kv the OpenID key/value data
              */
             void parse_keyvalues(const string& kv) {
                 from_keyvalues(kv); }
 
             string append_query(const string& url,const char *prefix="openid.") const;
 
     };
 
     struct openid_endpoint_t {
         string uri;
         string claimed_id;
         string local_id;
 
         openid_endpoint_t() { }
         openid_endpoint_t(const string& u,const string& cid,const string& lid)
             : uri(u), claimed_id(cid), local_id(lid) { }
 
         bool operator==(const openid_endpoint_t& x) const {
             return uri==x.uri && local_id==x.local_id; }
         bool operator<(const openid_endpoint_t& x) const {
             int c;
             return (c=strcmp(uri.c_str(),x.uri.c_str()))
                 ? (c<0) : (strcmp(local_id.c_str(),x.local_id.c_str())<0); }
     };
 
 }
 
 #endif /* __OPKELE_TYPES_H */