Types.h

// Types.h -- Definitions of some useful types.

/*
 * Copyright (C) 1997, 1998 Tudor Hulubei <tudor@hulubei.net>.
 *
 * This library 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, or (at
 * your option) any later version.
 *
 * 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 Lesser 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.
 */

/*
 * NOTE: This is an interal header file.
 * You should not attempt to use it directly.
 */

// $Id: Types_8h-source.html,v 1.1 2005/05/25 12:37:18 tudor Exp $

#ifndef _CSP_KERNEL_Types_H
#define _CSP_KERNEL_Types_H



CSP_NAMESPACE_BEGIN(csp);

class CSP_API Value;
class CSP_API Variable;
class CSP_API Constraint;
class CSP_API Solution;

template<class T> struct hash_id :
    public unary_function<T, size_t>
{
    size_t operator()(const T& key) const
    {
        return key->id();
    }
};

template<class T> struct equal_id :
    public binary_function<T, T, bool>
{
    bool operator()(const T& x, const T& y) const
    {
        return x->id() == y->id();
    }
};

template<class T> struct less_id :
    public binary_function<T, T, bool>
{
    bool operator()(const T& x, const T& y) const
    {
        return x->id() < y->id();
    }
};

CSP_NAMESPACE_END(csp);



#if defined(__GNUG__)
namespace __gnu_cxx
{
    template<> struct hash<const csp::Value*> {
        size_t operator()(const csp::Value* value) const {
            return reinterpret_cast<size_t>(value); }
    };

    template<> struct hash<const csp::Variable*> {
        size_t operator()(const csp::Variable* variable) const {
            return reinterpret_cast<size_t>(variable); }
    };

    template<> struct hash<const csp::Constraint*> {
        size_t operator()(const csp::Constraint* constraint) const {
            return reinterpret_cast<size_t>(constraint); }
    };

    template<> struct hash<const csp::Solution*> {
        size_t operator()(const csp::Solution* solution) const {
            return reinterpret_cast<size_t>(solution); }
    };

    template<> struct hash<csp::Value*> {
        size_t operator()(const csp::Value* value) const {
            return reinterpret_cast<size_t>(value); }
    };

    template<> struct hash<csp::Variable*> {
        size_t operator()(const csp::Variable* variable) const {
            return reinterpret_cast<size_t>(variable); }
    };

    template<> struct hash<csp::Constraint*> {
        size_t operator()(const csp::Constraint* constraint) const {
            return reinterpret_cast<size_t>(constraint); }
    };

    template<> struct hash<csp::Solution*> {
        size_t operator()(const csp::Solution* solution) const {
            return reinterpret_cast<size_t>(solution); }
    };
}
#endif // __GNUG__


CSP_NAMESPACE_BEGIN(csp);

/*
 * FIXME: These ids should be longlong, but the GNU STDC++ library
 * doesn't support longlong as a hash key yet.  Change this into
 * longlong as soon as that support is added.
 */

typedef int id_t;

const id_t NoId = -1;

#define ID_MAX INT_MAX
#define ID_MIN INT_MIN


class CSP_API Variable;
class CSP_API Constraint;


#if defined(__GNUG__)

    template<class T> struct hash_ptr :
        public unary_function<T, size_t> {
        size_t operator()(const T key) const {
            return reinterpret_cast<size_t>(key);
        }
    };

    template<class T> struct equal_ptr :
        public binary_function<T, T, bool> {
        bool operator()(const T x, const T y) const {
            return x == y;
        }
    };
#endif // __GNUG__


typedef list<Variable*> vlist_type;

typedef vlist_type::iterator vlist_iterator;

typedef vlist_type::const_iterator vlist_const_iterator;


typedef list<Constraint*> clist_type;

typedef clist_type::iterator clist_iterator;

typedef clist_type::const_iterator clist_const_iterator;


#if defined(__GNUG__)
typedef hash_set<
    csp::Variable*,
    csp::hash_id<csp::Variable*>,
    csp::equal_id<csp::Variable*> > vhash_type;
#elif defined(_MSC_VER)
typedef hash_set<
    csp::Variable*,
    hash_compare<
        csp::Variable*,
        csp::less_id<csp::Variable*> > > vhash_type;
#endif

typedef vhash_type::iterator vhash_iterator;

typedef vhash_type::const_iterator vhash_const_iterator;


#if defined(__GNUG__)
typedef hash_set<
    csp::Constraint*,
    csp::hash_id<csp::Constraint*>,
    csp::equal_id<csp::Constraint*> > chash_type;
#elif defined(_MSC_VER)
typedef hash_set<
    csp::Constraint*,
    hash_compare<
        csp::Constraint*,
        csp::less_id<csp::Constraint*> > > chash_type;
#endif

typedef chash_type::iterator chash_iterator;

typedef chash_type::const_iterator chash_const_iterator;


#if defined(__GNUG__)
typedef hash_set<
    csp::Solution*,
    csp::hash_id<csp::Solution*>,
    csp::equal_id<csp::Solution*> > shash_type;
#elif defined(_MSC_VER)
typedef hash_set<
    csp::Solution*,
    hash_compare<
        csp::Solution*,
        csp::less_id<csp::Solution*> > > shash_type;
#endif

typedef shash_type::iterator shash_iterator;

typedef shash_type::const_iterator shash_const_iterator;


CSP_NAMESPACE_END(csp);


#endif // _CSP_KERNEL_Types_H

// Local Variables:
// mode: C++
// End:

---