/home/archives/aegis/branch.4/branch.25/delta28933.505/libaegis/input.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 1999, 2002, 2004-2006, 2008, 2009, 2012 Peter Miller
//      Copyright (C) 2008, 2009 Walter Franzini
//
//      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/ac/sys/types.h>

#include <common/nstring.h>

class input; // forward

class input_ty
{
public:
    typedef input_ty* pointer;

    virtual ~input_ty();

    input_ty();

    ssize_t 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);

    void error(const char *msg);

    bool one_line(nstring &result);

    off_t ftell();

    virtual nstring name() = 0;

    virtual off_t 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::pointer 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 ssize_t read_inner(void *data, size_t nbytes) = 0;

    virtual off_t 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;
};


class input
{
    friend class input_ty;

public:
    ~input();

    input();

    input(input_ty::pointer arg);

    input(const input &arg);

    input &operator=(const input &arg);

#if 0

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

    input_ty::pointer operator->() { return ref; }

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

    void close();

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

    bool valid() const;

private:
    input_ty::pointer ref;
};


#endif // LIBAEGIS_INPUT_H
// vim: set ts=8 sw=4 et :