libarc.h

Go to the documentation of this file.

#ifndef __LIBARC_H__
#define __LIBARC_H__

#include <string>
#include <exception>
#include <iterator>

#include <netinet/in.h>
#include <stddef.h>

namespace libarc {

static const int LIBARC_VERSION = 0x000201;
static const char* LIBARC_VERSION_STRING = "0.2.1";

class Member_Iterator;
class Media_Type;


class Unsupported_ARC_Format_Exception : public std::exception
{
public:

    const char* what() const throw()
        {
            return "Unsupported ARC File format";
        }
};


class ARC_File
{
public:

    static ARC_File* Create(const char* arc_path);

    void Destroy();


    virtual off_t GetMemberCount(const char* media_type = 0) const = 0;


    virtual Member_Iterator* GetMemberIterator(const char* media_type = 0) const = 0;


    virtual Member_Iterator* GetMemberIterator(const Media_Type& media_type) const = 0;

protected:
    virtual ~ARC_File() throw();
};


class ARC_Member
{
public:

    virtual const Media_Type& MediaType() const = 0;

    virtual const std::string& URL() const = 0;

    virtual time_t Date() const = 0;

    virtual in_addr_t IPAddress() const = 0;


    virtual const unsigned char* GetData(off_t& length) const = 0;


    virtual int HTTPStatus() const = 0;


    virtual off_t GetOffset() const = 0;
    

    virtual off_t GetRawSize() const = 0;


    virtual off_t GetSize() const = 0;


    virtual void ReleaseData() const = 0;


    virtual const std::string& GetResponseHeader(const char* name) const = 0;

    virtual ~ARC_Member() throw();
};


class Member_Iterator
{
public:
    void Destroy();
    virtual const ARC_Member* Next() = 0;

protected:
    virtual ~Member_Iterator();
};


class Media_Type 
{
public:

    Media_Type(const char* mt = 0);


    Media_Type(const Media_Type& mt);

    const Media_Type& operator=(const char* mt)
        {
            parse_media_type(mt);
        }


    const Media_Type& operator=(const std::string& mt)
        {
            parse_media_type(mt.c_str());
        }


    const char* Type() const
        {
            return m_Type.c_str();
        }


    const char* Subtype() const
        {
            return m_Subtype.c_str();
        }


    bool compare(const Media_Type& mt) const;

private:
    void parse_media_type(const char* mt);

    std::string m_Type;
    std::string m_Subtype;
};


inline bool operator==(const Media_Type& lhs, const Media_Type& rhs)
{
    return lhs.compare(rhs);
}


template<typename Function>
void for_each(Member_Iterator* iter, Function f)
{
    const ARC_Member* m;
    while ((m = iter->Next()) != 0) {
        f(m);
    }
}


template<typename Predicate, typename Function>
void for_each_if(Member_Iterator* iter, Predicate p, Function f)
{
    const ARC_Member* m;
    while ((m = iter->Next()) != 0) {
        if (p(m)) {
            f(m);
        }
    }
}


template<typename Predicate>
const ARC_Member* find_if(Member_Iterator* iter, Predicate p)
{
    const ARC_Member* m;
    while ((m = iter->Next()) != 0) {
        if (p(m)) {
            return m;
        }
    }
    return 0;
}


template<typename Predicate>
size_t count_if(Member_Iterator* iter, Predicate p)
{
    const ARC_Member* m;
    size_t count = 0;
    
    while ((m = iter->Next()) != 0) {
        if (p(m)) {
            ++count;
        }
    }

    return count;
}
    
}; /* namespace */


#endif /* __LIBARC_H__ */

/*
Local Variables:
mode: c++
tab-width: 4
End:
*/

---

Generated on Tue Jun 8 21:30:14 2004 by