ClassServer.h

Go to the documentation of this file.

/*
 * opencog/atomspace/ClassServer.h
 *
 * Copyright (C) 2011 by The OpenCog Foundation
 * All Rights Reserved
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License v3 as
 * published by the Free Software Foundation and including the exceptions
 * at http://opencog.org/wiki/Licenses
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program; if not, write to:
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef _OPENCOG_CLASS_SERVER_H
#define _OPENCOG_CLASS_SERVER_H

#include <mutex>
#include <unordered_map>
#include <vector>

#include <boost/signals2.hpp>

#include <opencog/atomspace/types.h>
#include <opencog/atomspace/atom_types.h>

namespace opencog
{
class ClassServer;

typedef ClassServer* ClassServerFactory(void);

typedef boost::signals2::signal<void (Type)> TypeSignal;
class ClassServer
{
private:

    ClassServer();

    /* It is very tempting to make the type_mutex into a reader-writer
     * mutex. However, it appears that this is a bad idea: reader-writer
     * mutexes cause cache-line ping-ponging when there is contention,
     * effecitvely serializing access, and are just plain slower when
     * there is no contention.  Thus, the current implementations seem
     * to be a lose-lose proposition. See the Anthony Williams post here:
     * http://permalink.gmane.org/gmane.comp.lib.boost.devel/211180
     */
    mutable std::mutex type_mutex;

    Type nTypes;

    std::vector< std::vector<bool> > inheritanceMap;
    std::vector< std::vector<bool> > recursiveMap;
    std::unordered_map<std::string, Type> name2CodeMap;
    std::unordered_map<Type, const std::string*> code2NameMap;
    TypeSignal _addTypeSignal;

    void setParentRecursively(Type parent, Type type);

public:
    static ClassServer* createInstance(void);

    Type addType(const Type parent, const std::string& name);

    TypeSignal& addTypeSignal();

    template<typename OutputIterator>
    unsigned long getChildren(Type type, OutputIterator result)
    {
        unsigned long n_children = 0;
        for (Type i = 0; i < nTypes; ++i) {
            if (inheritanceMap[type][i] && (type != i)) {
                *(result++) = i;
                n_children++;
            }
        }
        return n_children;
    }

    template <typename OutputIterator>
    unsigned long getChildrenRecursive(Type type, OutputIterator result)
    {
        unsigned long n_children = 0;
        for (Type i = 0; i < nTypes; ++i) {
            if (recursiveMap[type][i] && (type != i)) {
                *(result++) = i;
                n_children++;
            }
        }
        return n_children;
    }

    template <typename Function>
    void foreachRecursive(Function func, Type type)
    {
        for (Type i = 0; i < nTypes; ++i) {
            if (recursiveMap[type][i]) (func)(i);
        }
    }

    Type getNumberOfClasses();

    bool isA(Type sub, Type super)
    {
        /* Because this method is called extremely often, we want
         * the best-case fast-path for it.  Since updates are extremely
         * unlikely after initialization, we use a multi-reader lock,
         * and don't care at all about writer starvation, since there
         * will almost never be writers. However, see comments above
         * about multi-reader-locks -- we are not using them just right
         * now, because they don't seem to actually help. */
        std::lock_guard<std::mutex> l(type_mutex);
        if ((sub >= nTypes) || (super >= nTypes)) return false;
        return recursiveMap[super][sub];
    }

    bool isA_non_recursive(Type sub, Type super);

    bool isValid(Type t) { return isA(t, ATOM); }

    bool isLink(Type t) { return isA(t, LINK); }

    bool isNode(Type t) { return isA(t, NODE); }

    bool isDefined(const std::string& typeName);

    Type getType(const std::string& typeName);

    const std::string& getTypeName(Type type);
};

ClassServer& classserver(ClassServerFactory* = ClassServer::createInstance);

} // namespace opencog

#endif // _OPENCOG_CLASS_SERVER_H