Id.h

Go to the documentation of this file.

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           Copyright (C) 2003-2007 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/

#ifndef _ID_H
#define _ID_H

class Id
{
public:
    //  Id creation

    Id();

    Id( unsigned int id );

    Id( const std::string& path, const std::string& separator = "/" );

    Id( const ObjId& oi );

    ~Id() {}

    static Id nextId();


    static unsigned int numIds();

    void bindIdToElement( Element* e );

    void destroy() const;

    //  Id info

    std::string path( const std::string& separator = "/" ) const;


    Element* element() const;

//      unsigned int index() const;

    Eref eref() const;

    static Id str2Id( const std::string& s );

    static std::string id2str( Id id );

    unsigned int value() const;

    //  Comparisons between ids
    bool operator==( const Id& other ) const
    {
        // return id_ == other.id_ && index_ == other.index_;
        return id_ == other.id_;
    }

    bool operator!=( const Id& other ) const
    {
        // return id_ != other.id_ || index_ != other.index_;
        return id_ != other.id_;
    }

    bool operator<( const Id& other ) const
    {
        //  return ( id_ < other.id_ ) ||
        //      ( id_ == other.id_ && index_ < other.index_ );
        return ( id_ < other.id_ );
    }

    // The follwoing two functions check if the Id is associated with
    // an existing element. Needed for handling objects that have been destroyed.
    static bool isValid(Id id)
    {
        return (id.id_ < elements().size()) && (elements()[id.id_] != 0);
    }

    static bool isValid(unsigned int id)
    {
        return (id < elements().size()) && (elements()[id] != 0);
    }


    static void clearAllElements();

    void zeroOut() const;

    friend ostream& operator <<( ostream& s, const Id& i );
    friend istream& operator >>( istream& s, Id& i );

private:
    // static void setManager( Manager* m );
    unsigned int id_; // Unique identifier for Element*
//      unsigned int index_; // Index of array entry within element.
    static vector< Element* >& elements();
};

// User defined hash function. 
// See https://en.cppreference.com/w/cpp/utility/hash for more details.
namespace std 
{
    template <> 
    struct hash<Id> 
    {
        public :
            size_t operator()(const Id &x ) const
            {
                return std::hash<unsigned int>()( x.value() );
            }
    };
}

#endif // _ID_H