chain.h

Go to the documentation of this file.

/*  Glass - a distributed computing library
    Copyright (C) 2003-2009 Bruno Barberi Gnecco
    Copyright (C) 2009-2010 Corollarium Technologies


    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 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
    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
 */

#ifndef _GLASS_CHAIN_HH_
#define _GLASS_CHAIN_HH_

#include "msvc.h"
#include "types.h"
#include "exception.h"
#include <string.h>
#include <list>
#include <iostream>
#include <limits.h>

namespace libglass {

class chain;

class LIBGLASS_API record {
#if defined(_MSC_VER)
public:
#else
private:
#endif // _MSC_VER

        record();
        record *operator=(const record *s);

protected:
        struct _record {
                unsigned int    references;     
                bool            allocated;      
                unsigned int    size;           
                const char      *data;          
        };
        _record         *r;                     
        int             offset;                 
        int             roffset;                
public:

        record(const char *p, unsigned int size, bool allocated, 
                const char *allocateddata = NULL);

        record(const record *r, int offset = 0, int roffset = 0);

        record(const record &r, int offset = 0, int roffset = 0);

        ~record();

        record &operator=(const record &s);

        const char *getData(void) const;

        unsigned int getLength(void) const;

        void print() const;
};

class chain_iterator {
private:
        std::list<record>::iterator it;         
protected:
        friend class chain;

        void setiterator(std::list<record>::iterator it) {
                this->it = it;
        }

public:
        chain_iterator() { }

        const chain_iterator& operator++() { // Prefix
                ++it;
                return *this;
        }

        const chain_iterator operator++(int) { // Postfix
                it++;
                return *this;
        }

        const chain_iterator& operator--() { // Prefix
                --it;
                return *this;
        }

        const chain_iterator operator--(int) { // Postfix
                it--;
                return *this;
        }

        bool operator==(const chain_iterator &i) const {
                return (this->it == i.it);
        }

        bool operator!=(const chain_iterator &i) const {
                return (this->it != i.it);
        }

        const char *data(void) const {
                return it->getData();
        }

        unsigned int size(void) const {
                return it->getLength();
        }
};

#if defined(_MSC_VER)
// Instantiate std::list<T> template containers used by class chain
LIBGLASS_IMP_TEMPLATE_STL_LIST(libglass::record);
#endif // _MSC_VER

// class chain {
class LIBGLASS_API chain {
public:
        // iterators
        typedef chain_iterator iterator;

#if defined(_MSC_VER) && (_MSC_VER < 1300)  // earlier than .NET compiler (VC 7.0)
        // Microsoft Knowledge Base Article - 241569 
        // Workaround for BUG: C2258 and C2252 on in Place Initialization of Static Const Members
        enum{ npos = UINT_MAX };
#else
        static const unsigned int npos = UINT_MAX;
#endif

private: 
        const char *getPosition(unsigned int position) const throw(Exception);

protected:
        friend class chain_iterator;

        std::list<record>       pieces;

public:
        chain();

        chain(const char *p, unsigned int s = 0);

        chain(std::string &s);

        ~chain();

        void clear(void);

        unsigned int size(void) const;

        unsigned int length(void) const;

        char &operator[](unsigned int position) throw(Exception);

        const chain &operator=(const chain &s);

        const chain &assign(char *p, unsigned int s = 0, bool free = false,
                        char *allocatedbegin = NULL);

        const chain &assign(std::string &s);

        const chain &assign(const chain &s);

        const bool operator<(const chain &c) const;

        const chain &operator+=(const chain &s);

        const chain &operator+=(char *p);
        
        const chain &operator+=(std::string &s);

#ifdef TODO
        const chain operator+(const chain &s) const;
#endif

        bool operator==(const chain &s) const;

        bool operator!=(const chain &s) const;

        void append(const chain &s);

        void append(const char *p, unsigned int s = 0, bool free = false,
                                char *allocatedbegin = NULL);

        void append(std::string &s);

        void appendcopy(chain &s);

        void appendcopy(const char *p, unsigned int s = 0);

        void appendcopy(std::string &s);

#ifdef DEPRECATED

        chain *concatenate(int begin = 0, int end = -1) const;
#endif

        char *toArray(unsigned int begin = 0, unsigned int end = npos) 
                        const throw(Exception);

        std::string toString(unsigned int begin = 0, unsigned int end = npos) 
                        const throw(Exception);

        int toInt(unsigned int begin = 0) const throw(Exception);

        chain substr(unsigned int begin, unsigned int end) const throw(Exception);

        bool substrcopy(char *dest, unsigned int begin, unsigned int end) const
                        throw(Exception);

        chain duplicate(void);

        unsigned int find(char c, unsigned int initial = 0) const;

        // iterator
        chain_iterator begin(void);

        chain_iterator end(void);

        void erase(chain_iterator it);

        void debug(void) const;

        friend std::ostream& operator<<(std::ostream &o, chain &p);
};

extern std::ostream& operator<<(std::ostream &o, chain &p);

} //namespace


#endif // _GLASS_CHAIN_HH_

---