words.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  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;
// either version 2 of the License, 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on May 5, 2002. Last revision: February 21, 2007.


#ifndef _CHOMP_STRUCT_WORDS_H_
#define _CHOMP_STRUCT_WORDS_H_

#include "chomp/system/config.h"
#include "chomp/struct/integer.h"
#include "chomp/system/textfile.h"
#include "chomp/struct/hashsets.h"

#include <cstdlib>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>

namespace chomp {
namespace homology {


// the data types defined within this file
class word;

typedef hashedset<word> words;


// --------------------------------------------------
// ---------------------- word ----------------------
// --------------------------------------------------

class word
{
public:
        word ();

        word (const char *s);

        word (const word &w);

        ~word ();

        word &operator = (const word &w);

        int length () const;

        const char *text () const;

        operator const char * () const;

        word &operator += (const word &w);

        word operator + (const word &w) const;

        operator int () const;

private:
        int len;

        char *txt;

}; /* class word */

// --------------------------------------------------

inline word::word ()
{
        len = 0;
        txt = NULL;
        return;
} /* word::word */

inline word::word (const char *s)
{
        len = s ? strlen (s) : 0;
        if (!len)
                txt = NULL;
        else
        {
                txt = new char [len + 1];
                if (!txt)
                        throw "Not enough memory to create a word.";
                strcpy (txt, s);
        }
        return;
} /* word::word */

inline word::word (const word &w)
{
        len = w. len;
        if (!len)
                txt = NULL;
        else
        {
                txt = new char [len + 1];
                if (!txt)
                        throw "Not enough memory to copy a word.";
                strcpy (txt, w. txt);
        }
        return;
} /* word::word */

inline word::~word ()
{
        if (txt)
                delete [] txt;
        return;
} /* word::~word */

inline word &word::operator = (const word &w)
{
        if (txt)
                delete [] txt;
        len = w. len;
        if (w. txt)
        {
                txt = new char [len + 1];
                if (!txt)
                        throw "Not enough memory to copy a word.";
                strcpy (txt, w. txt);
        }
        else
                txt = NULL;
        return *this;
} /* operator = */

inline int word::length () const
{
        return len;
} /* length */

inline const char *word::text () const
{
        return txt;
} /* text */

inline word::operator const char * () const
{
        return txt;
} /* operator int */

inline word &word::operator += (const word &w)
{
        if (!len)
        {
                *this = w;
                return *this;
        }
        if (!w. len)
                return *this;
        int newlen = len + w. len;
        char *newtxt = new char [newlen + 1];
        strcpy (newtxt, txt);
        strcat (newtxt, w. txt);
        delete [] txt;
        txt = newtxt;
        len = newlen;
        return *this;
} /* operator += */

inline word word::operator + (const word &w) const
{
        word new_w (*this);
        new_w += w;
        return new_w;
} /* operator + */

inline word::operator int () const
{
        if (!len)
                return 0;
        char *s = txt;
        if (*s == '+')
                ++ s;
        int num;
        std::istringstream str (s);
        str >> num;
        if (!str)
                return 0;
        else
                return num;
} /* operator int */

// --------------------------------------------------

inline int_t hashkey1 (const word &w)
{
        int len = w. length ();
        if (!len)
                return 13;
        const char *txt = w. text ();
        int_t code = (static_cast<int_t> (txt [0]) << 7) ^
                (static_cast<int_t> (txt [len - 1]));
        if (len > 3)
                code ^= static_cast<int_t> (txt [2]) << 15;
        return code;
} /* word::hashkey1 */

inline int_t hashkey2 (const word &w)
{
        int len = w. length ();
        if (!len)
                return 7;
        const char *txt = w. text ();
        int_t code = (static_cast<int_t> (txt [0])) ^
                (static_cast<int_t> (txt [len - 1] << 17));
        if (len > 4)
                code ^= static_cast<int_t> (txt [3]) << 8;
        return code;
} /* word::hashkey2 */

inline int operator == (const word &w1, const word &w2)
{
        if (w1. length () != w2. length ())
                return 0;
        if (!w1. length ())
                return 1;
        return !strcmp ((const char *) w1, (const char *) w2);
} /* operator == */

inline int operator != (const word &w1, const word &w2)
{
        return !(w1 == w2);
} /* operator != */

inline int operator == (const word &w, const char *c)
{
        if (!w. length ())
                return (!c || !*c);
        return !strcmp ((const char *) w, c);
} /* operator == */

inline int operator != (const word &w, const char *c)
{
        return !(w == c);
} /* operator != */

inline int operator == (const char *c, const word &w)
{
        return (w == c);
} /* operator == */

inline int operator != (const char *c, const word &w)
{
        return (w != c);
} /* operator != */

// --------------------------------------------------

inline int operator < (const word &w1, const word &w2)
{
        const char *c1 = (const char *) w1;
        const char *c2 = (const char *) w2;

        while (*c1 && *c2 && ((*c1) == (*c2)))
        {
                ++ c1;
                ++ c2;
        }
        return ((*c1) < (*c2));
} /* operator < */

inline int operator > (const word &w1, const word &w2)
{
        return (w2 < w1);
} /* operator > */

inline int operator <= (const word &w1, const word &w2)
{
        return !(w1 > w2);
} /* operator <= */

inline int operator >= (const word &w1, const word &w2)
{
        return !(w1 < w2);
} /* operator >= */


// --------------------------------------------------

template <class type>
word &operator << (word &w, const type &elem)
{
        std::ostringstream s;
        s << elem;
        w += s. str (). c_str ();
        return w;
} /* operator << */


// --------------------------------------------------

inline std::ostream &operator << (std::ostream &out, const word &w)
{
        if (w. length ())
                out << (const char *) w;
        return out;
} /* operator << */

inline std::istream &operator >> (std::istream &in, word &w)
{
        char buf [256 + 1];
        int pos = 0;
        int ch = in. peek ();
        while ((ch != ' ') && (ch != '\r') && (ch != '\n') && (ch != '\t') &&
                (ch != EOF))
        {
                buf [pos ++] = in. get ();
                ch = in. peek ();
                if (pos >= 256)
                        break;
        }
        buf [pos] = '\0';
        w = word (buf);
        return in;
} /* operator >> */


} // namespace homology
} // namespace chomp

#endif // _CHOMP_STRUCT_WORDS_H_