include/dlvhex2/Registry.h

Go to the documentation of this file.

/* dlvhex -- Answer-Set Programming with external interfaces.
 * Copyright (C) 2005-2007 Roman Schindlauer
 * Copyright (C) 2006-2015 Thomas Krennwallner
 * Copyright (C) 2009-2016 Peter Schüller
 * Copyright (C) 2011-2016 Christoph Redl
 * Copyright (C) 2015-2016 Tobias Kaminski
 * Copyright (C) 2015-2016 Antonius Weinzierl
 *
 * This file is part of dlvhex.
 *
 * dlvhex is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * dlvhex 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 Lesser General Public
 * License along with dlvhex; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#ifndef REGISTRY_HPP_INCLUDED_14012011
#define REGISTRY_HPP_INCLUDED_14012011

#include "dlvhex2/PlatformDefinitions.h"
#include "dlvhex2/fwd.h"
#include "dlvhex2/Printhelpers.h"
#include "dlvhex2/ID.h"
#include "dlvhex2/TermTable.h"
#include "dlvhex2/PredicateTable.h"
#include "dlvhex2/OrdinaryAtomTable.h"
#include "dlvhex2/BuiltinAtomTable.h"
#include "dlvhex2/AggregateAtomTable.h"
#include "dlvhex2/ExternalAtomTable.h"
#include "dlvhex2/ModuleAtomTable.h"
#include "dlvhex2/RuleTable.h"
#include "dlvhex2/ModuleTable.h"
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <bm/bm.h>

DLVHEX_NAMESPACE_BEGIN

class AuxPrinter
{
    public:
        virtual ~AuxPrinter() {}
        virtual bool print(std::ostream& out, ID id, const std::string& prefix) const = 0;
};

struct DLVHEX_EXPORT Registry:
public ostream_printable<Registry>,
public boost::enable_shared_from_this<Registry>
{
    public:
        Registry();
        explicit Registry(const Registry& other);
        ~Registry();

        TermTable terms;
        PredicateTable preds;
        OrdinaryAtomTable ogatoms;
        OrdinaryAtomTable onatoms;
        BuiltinAtomTable batoms;
        AggregateAtomTable aatoms;
        ExternalAtomTable eatoms;
        ModuleAtomTable matoms;
        RuleTable rules;
        ModuleTable moduleTable;
        std::vector<Tuple> inputList;

        EAInputTupleCachePtr eaInputTupleCache;

        //
        // modifiers
        //

        ID storeOrdinaryAtom(OrdinaryAtom& ogatom);
        ID storeOrdinaryGAtom(OrdinaryAtom& ogatom);
        ID storeOrdinaryNAtom(OrdinaryAtom& onatom);

        ID storeConstOrVarTerm(Term& term);

        ID storeConstantTerm(const std::string& symbol, bool aux=false);

        ID storeVariableTerm(const std::string& symbol, bool aux=false);

        ID storeTerm(Term& term);

        ID getNewConstantTerm(std::string prefix = "unnamed");

        ID storeRule(Rule& rule);

        //
        // auxiliary management
        //

        void setupAuxiliaryGroundAtomMask();

        ID getAuxiliaryConstantSymbol(char type, ID id);

        ID getAuxiliaryVariableSymbol(char type, ID id);

        ID getAuxiliaryAtom(char type, ID id);

        ID getIDByAuxiliaryConstantSymbol(ID auxConstantID) const;

        ID getIDByAuxiliaryVariableSymbol(ID auxVariableID) const;

        bool isPositiveExternalAtomAuxiliaryAtom(ID auxID);

        bool isNegativeExternalAtomAuxiliaryAtom(ID auxID);

        ID swapExternalAtomAuxiliaryAtom(ID auxID);

        char getTypeByAuxiliaryConstantSymbol(ID auxConstantID) const;

        inline bool isNullTerm(ID term) const
        {
            return term.isAuxiliary() && getTypeByAuxiliaryConstantSymbol(term) == '0';
        }

        InterpretationConstPtr getAuxiliaryGroundAtomMask();

        //
        // accessors
        //

        // cannot be nonconst as printing might change registry caches
        // (TODO create mutable string caches in atoms)
        std::ostream& print(std::ostream& o);
        virtual std::ostream& print(std::ostream& o) const { return const_cast<Registry*>(this)->print(o); }

        const OrdinaryAtom& lookupOrdinaryAtom(ID id) const;

        inline const std::string& getTermStringByID(ID termid) const
            { return terms.getByID(termid).symbol; }

        void getExternalAtomsInTuple(const Tuple& t, Tuple& out) const;

        void getVariablesInID(ID id, std::set<ID>& out, bool includeAnonymous = false, bool includeLocalAggVar = true) const;

        std::set<ID> getVariablesInID(const ID& id, bool includeAnonymous = false, bool includeLocalAggVar = true) const;

        void getOutVariablesInID(ID id, std::set<ID>& out, bool includeAnonymous = false, bool includeLocalAggVar = true) const;

        void getVariablesInTuple(const Tuple& t, std::set<ID>& out, bool includeAnonymous = false, bool includeLocalAggVar = true) const;

        std::set<ID> getVariablesInTuple(const Tuple& t, bool includeAnonymous = false, bool includeLocalAggVar = true) const;

        ID replaceVariablesInTerm(const ID term, const ID var, const ID by);

        ID getPredicateOfAtom(ID atom);

        //
        // printing framework
        //

        // these printers are used as long as none prints it
        void registerUserAuxPrinter(AuxPrinterPtr printer);

        // this one printer is used last
        void registerUserDefaultAuxPrinter(AuxPrinterPtr printer);

        bool printAtomForUser(std::ostream& o, IDAddress address, const std::string& prefix="");

    protected:
        struct Impl;
        boost::scoped_ptr<Impl> pimpl;
};
typedef boost::shared_ptr<Registry> RegistryPtr;

DLVHEX_NAMESPACE_END
#endif                           // REGISTRY_HPP_INCLUDED_14012011

// vim:expandtab:ts=4:sw=4:
// mode: C++
// End: