libaegis/input.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 1999, 2002, 2004-2006, 2008 Peter Miller
//
//      This program 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 3 of the License, or
//      (at your option) any later version.
//
//      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 General Public License
//      along with this program. If not, see
//      <http://www.gnu.org/licenses/>.
//

#ifndef LIBAEGIS_INPUT_H
#define LIBAEGIS_INPUT_H

#include <common/nstring.h>
#include <common/main.h>

class input; // forward

class input_ty
{
public:
    virtual ~input_ty();

    input_ty();

    long read(void *data, size_t nbytes);

    void read_strictest(void *data, size_t size);

    bool read_strict(void *data, size_t size);

    void skip(size_t size);

    void fatal_error(const char *msg);

    bool one_line(nstring &result);

    long ftell();

    virtual nstring name() = 0;

    virtual long length() = 0;

    int
    getch()
    {
        if (buffer_position < buffer_end)
            return *buffer_position++;
        return getc_complicated();
    }

    void
    ungetc(int c)
    {
        if (c >= 0)
        {
            if (buffer_position > buffer)
                *--buffer_position = c;
            else
                ungetc_complicated(c);
        }
    }

    int
    peek()
    {
        int c = getch();
        ungetc(c);
        return c;
    }

    virtual void keepalive();

    void pushback_transfer(input &from);

    void pullback_transfer(input_ty *to);

    void pullback_transfer(input &to);

    void unread(const void *data, size_t nbytes);

    bool at_end();

    virtual bool is_remote() const;

    void reference_count_up();
    void reference_count_down();
    bool reference_count_valid() const { return (reference_count >= 1); }

protected:
    virtual long read_inner(void *data, size_t nbytes) = 0;

    virtual long ftell_inner() = 0;

    int getc_complicated();

    void ungetc_complicated(int c);

private:
    long reference_count;

    unsigned char *buffer;

    size_t buffer_size;

    unsigned char *buffer_position;

    unsigned char *buffer_end;
};


inline DEPRECATED string_ty *
input_name(input_ty *ip)
{
    return ip->name().get_ref();
}


inline DEPRECATED void
input_delete(input_ty *ip)
{
    ip->reference_count_down();
}


inline DEPRECATED int
input_getc(input_ty *ip)
{
    return ip->getch();
}


inline DEPRECATED void
input_ungetc(input_ty *ip, int c)
{
    ip->ungetc(c);
}


inline DEPRECATED long
input_length(input_ty *ip)
{
    return ip->length();
}


inline DEPRECATED long
input_read(input_ty *ip, void *data, size_t nbytes)
{
    return ip->read(data, nbytes);
}


inline DEPRECATED void
input_fatal_error(input_ty *ip, const char *msg)
{
    ip->fatal_error(msg);
}


class input
{
    friend class input_ty;

public:
    ~input();

    input();

    input(input_ty *arg);

    input(const input &arg);

    input &operator=(const input &arg);

#if 0

    input &operator=(input *arg);
#endif

    input_ty *operator->() { return ref; }

    const input_ty *operator->() const { return ref; }

    void close();

    bool is_open() const { return (ref != 0); }

    bool valid() const;

private:
    input_ty *ref;
};


#endif // LIBAEGIS_INPUT_H

---