NameServer.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: Peter Soetens  Thu Oct 10 16:16:57 CEST 2002  NameServer.hpp

                        NameServer.hpp -  description
                           -------------------
    begin                : Thu October 10 2002
    copyright            : (C) 2002 Peter Soetens
    email                : peter.soetens@mech.kuleuven.ac.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef ORO_NAMESERVER_HPP
#define ORO_NAMESERVER_HPP

#include <iterator>
#include <string>
#include <map>
// #include "rtt-config.h"
// #ifdef OROPKG_CORELIB_REPORTING
// #include "../../Logger.hpp"
// #endif

namespace RTT
{ namespace dev {

    template < class _ValueType >
    class NameServer
    {
    public:
        typedef _ValueType ValueType;
        typedef std::string NameType;
        typedef std::map<NameType, ValueType> Rep;
        typedef typename Rep::iterator iterator;
        typedef typename Rep::const_iterator const_iterator;

        NameServer() : objects()
        {}

        ~NameServer()
        {}

        bool isNameRegistered( const NameType& s ) const
        {
            return ( objects.find( s ) != objects.end() );
        }

        bool isObjectRegistered( const ValueType o ) const
        {
            for ( const_iterator i = objects.begin(); i != objects.end(); ++i )
                {
                    if ( ( *i ).second == o )
                        return true;
                }

            return false;
        }

        ValueType getObject( const NameType& s ) const
        {
            const_iterator itc = objects.find( s );
            if ( itc == objects.end() )
                return ValueType();
            return( *itc ).second;
        }

        const NameType&
        getName( const ValueType s ) const
        {
            for ( const_iterator i = objects.begin(); i != objects.end(); ++i )
                {
                    if ( ( *i ).second == s )
                        return ( *i ).first;
                }

            return NoName;
        }

        bool registerObject( const ValueType obj, const NameType& name )
        {
            if ( isNameRegistered( name ) )
                return false;
// #ifdef OROPKG_CORELIB_REPORTING
//             Logger::log() << Logger::Debug << "NameServer : Adding " << name << Logger::endl;
// #endif
            objects.insert(std::make_pair(name,obj));
            return true;
        }

        void unregisterObject( const ValueType obj )
        {
            iterator i(objects.begin());

            for(;;)
                {
                    for ( i = objects.begin();
                          i != objects.end();
                          ++i )
                        {
                            if ( ( *i ).second == obj )
                                break;
                        }

                    if ( i == objects.end() ) return;
// #ifdef OROPKG_CORELIB_REPORTING
//                         Logger::log() << Logger::Debug << "NameServer : Removing " << (*i).first << Logger::endl;
// #endif
                       objects.erase( i );
                }
        }

        void unregisterName( const NameType& name )
        {
            iterator i( objects.find( name ) );

            if ( i != objects.end() ) {
                objects.erase( i );
// #ifdef OROPKG_CORELIB_REPORTING
//                 Logger::log() << Logger::Debug << "NameServer : Removing " << name << Logger::endl;
// #endif
                    }
        }

#if __GNUC__ == 2
        class value_iterator : public bidirectional_iterator<ValueType, int>
#else
        class value_iterator : public std::iterator<std::input_iterator_tag, ValueType>
#endif
        {
        protected:
                typename NameServer<_ValueType>::iterator i;

        public:
            value_iterator( iterator _i ) : i( _i )
            {}

            ValueType operator*()
            {
                return ( ( *i ).second );
            }

            value_iterator& operator++()
            {
                ++i;
                return *this;
            }

            value_iterator& operator--()
            {
                --i;
                return *this;
            }

            value_iterator operator++( int )
            {
                value_iterator ret;
                operator++();
                return ret;
            }

            value_iterator operator--( int )
            {
                value_iterator ret;
                operator--();
                return ret;
            }

            bool operator==( value_iterator other )
            {
                return ( i == other.i );
            }

            bool operator!=( value_iterator other )
            {
                return ( i != other.i );
            }

            int operator- ( value_iterator other )
            {
                return ( i -other.i );
            }
        };

#if __GNUC__ == 2
        class name_iterator : public bidirectional_iterator<NameType, int>
#else
        class name_iterator : public std::iterator< std::input_iterator_tag , NameType>
#endif
        {

        protected:
                typename NameServer<_ValueType>::iterator i;

        public:

            name_iterator( iterator _i ) : i( _i )
            {}

            NameType operator*()
            {
                return ( ( *i ).first );
            }

            name_iterator operator++( int )
            {
                name_iterator ret( i );
                operator++();
                return ret;
            }

            name_iterator& operator++()
            {
                ++i;
                return *this;
            }

            name_iterator& operator--()
            {
                --i;
                return *this;
            }

            name_iterator operator--( int )
            {
                name_iterator ret( i );
                operator--();
                return ret;
            }

            bool operator==( name_iterator other )
            {
                return ( i == other.i );
            }

            bool operator!=( name_iterator other )
            {
                return ( i != other.i );
            }

            int operator- ( name_iterator other )
            {
                return ( i -other.i );
            }
        };

        name_iterator getNameBegin() { return name_iterator( objects.begin() ); }

        name_iterator getNameEnd() { return name_iterator( objects.end() ); }

        value_iterator getValueBegin() { return value_iterator( objects.begin() ); }

        value_iterator getValueEnd() { return value_iterator( objects.end() ); }

    private:
        Rep objects;
        static NameType NoName;
    };

    template<class T>
    std::string NameServer<T>::NoName;

}}

#endif // NAMESERVER_HPP