Welcome to the NetCologne GmbH open source mirroring service!

This machine mirrors various open-source projects. 20 Gbit/s uplink.

If there are any issues or you want another project mirrored, please contact mirror-service -=AT=- netcologne DOT de !

Logical.H

Go to the documentation of this file.

/*===========================================================================*/
/*
 * This file is part of libogg++ - a c++ library for the Ogg transport format
 *
 * Copyright (C) 2006, 2007, 2008 Elaine Tsiang YueLien
 *
 * libogg++ 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.1 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.
 * 51 Franklin Street, Fifth Floor
 * Boston, MA  02110-1301, USA
 *
 *===========================================================================*/
/*===========================================================================*/
#ifndef LogicalToApplicationInterface
#define LogicalToApplicationInterface

#ifdef __GNUG__
#pragma interface
#endif


namespace       Ogg
{
  class Logical;
  class Packet;
}

#include        <Ogg/Ogg.H>
#include        <Ogg/Transport.H>
#include        <Ogg/Exception.H>

namespace       Ogg
{


  class Packet
  {
  private:
    Packet(const Packet &);

    Packet &
    operator =(const Packet &);

  protected:
    Packet(){};

  public:
    void
    data(void *
         ,size_t
         );

    void *
    data();             
    
    size_t
    size();             

    PacketNo            
    packetNo();

  };

  class Logical
  {
  private:
    void *              impl_;

    Logical(const Logical &);

    Logical &
    operator =(const Logical &);

  protected:
    Logical(
            bool        dummy
            )
      : impl_(0)
    {}

  public:
    void *
    impl()
    {
      return(impl_);
    }

    /*----- Exceptions thrown by a Logical thread ---------------------------------*/

    class SerialNotPositive : public Exception
    {
    public:
      SerialNotPositive(
                        const long      serialNo
                        ) throw()
        : Exception("Serial no. ")
      {
        *this << serialNo << "is not positive" << std::endl;
      }
      
      SerialNotPositive(
                        const SerialNotPositive & ex
                        ) throw()
        : Exception(ex)
      {}
      
      ~SerialNotPositive() throw()
      {}
    }
    ;

    class WriterAlreadyExists : public Exception
    {
    public:
      WriterAlreadyExists(
                          const long    serialNo
                          ) throw()
        : Exception("Writer for this Logical already exists,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }
      
      WriterAlreadyExists(
                          const WriterAlreadyExists & ex
                          ) throw()
        : Exception(ex)
      {}
      
      ~WriterAlreadyExists() throw()
      {}
    }
    ;

    class NotForWriting : public Exception
    {
    public:
      NotForWriting(
                    const long  serialNo
                    ) throw()
        : Exception("This Logical not for writing")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      NotForWriting(
                    const NotForWriting & ex
                    ) throw()
        : Exception(ex)
      {}

      ~NotForWriting() throw()
      {}
    }
    ;

    class ReaderAlreadyExists : public Exception
    {
    public:
      ReaderAlreadyExists(
                          const long    serialNo
                          ) throw()
        : Exception("Reader for this Logical already exists,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }
      
      ReaderAlreadyExists(
                          const ReaderAlreadyExists & ex
                          ) throw()
        : Exception(ex)
      {}
      
      ~ReaderAlreadyExists() throw()
      {}
    }
    ;

    class NotForReading : public Exception
    {
    public:
      NotForReading(
                    const long  serialNo
                    ) throw()
        : Exception("This Logical not for reading,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      NotForReading(
                    const NotForReading & ex
                    ) throw()
        : Exception(ex)
      {}

      ~NotForReading() throw()
      {}
    }
    ;

    class MuxTooLate : public Exception
    {
    public:
      MuxTooLate(
                 const long     serialNo
                 ) throw()
        : Exception("This Logical stream comes in too late - synchronize better,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      MuxTooLate(
                 const MuxTooLate & ex
                 ) throw()
        : Exception(ex)
      {}

      ~MuxTooLate() throw()
      {}
    }
    ;

    class SerialNoAlreadyUsed : public Exception
    {
    public:
      SerialNoAlreadyUsed(
                          const long    serialNo
                          ) throw()
        : Exception("This serial no. has been taken already,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      SerialNoAlreadyUsed(
                          const SerialNoAlreadyUsed & ex
                          ) throw()
        : Exception(ex)
      {}
      
      ~SerialNoAlreadyUsed() throw()
      {}
    }
    ;

    class StreamAlreadyClaimed : public Exception
    {
    public:
      StreamAlreadyClaimed(
                           const long   serialNo
                          ) throw()
        : Exception("Stream already has been claimed,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }
      
      StreamAlreadyClaimed(
                           const StreamAlreadyClaimed & ex
                          ) throw()
        : Exception(ex)
      {}
      
      ~StreamAlreadyClaimed() throw()
      {}
    }
    ;

    class NoSuchStream : public Exception
    {
    public:
      NoSuchStream(
                   const long   serialNo
                   ) throw()
        : Exception("No stream found,")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      NoSuchStream(
                   const NoSuchStream & ex
                   ) throw()
        : Exception(ex)
      {}
      
      ~NoSuchStream() throw()
      {}
    }
    ;

    class FailedToSelectStream : public Exception
    {
    public:
      FailedToSelectStream(
                           const long   serialNo
                           ) throw()
        : Exception("Failed to find a stream with ")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      FailedToSelectStream(
                           const FailedToSelectStream & ex
                           ) throw()
        : Exception(ex)
      {}
      
      ~FailedToSelectStream() throw()
      {}
    }
    ;

    class SeekInternalError : public Exception
    {
    public:
      SeekInternalError(
                        const long      serialNo
                        ) throw()
        : Exception("Please let developers know this happened.")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      SeekInternalError(
                        const SeekInternalError & ex
                        ) throw()
        : Exception(ex)
      {}
      
      ~SeekInternalError() throw()
      {}
    }
    ;

    class PageReaderTooLate : public Exception
    {
    public:
      PageReaderTooLate(
                        const long      serialNo
                        ) throw()
        : Exception("Request for PageReader must precede that for Reader.")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      PageReaderTooLate(
                        const PageReaderTooLate & ex
                        ) throw()
        : Exception(ex)
      {}
      
      ~PageReaderTooLate() throw()
      {}
    }
    ;

    class ReaderTooLate : public Exception
    {
    public:
      ReaderTooLate(
                    const long  serialNo
                    ) throw()
        : Exception("Logical::reader() must precede PageReader::get()")
      {
        *this << " serial no. = " << serialNo << std::endl;
      }

      ReaderTooLate(
                    const ReaderTooLate & ex
                    ) throw()
        : Exception(ex)
      {}
      
      ~ReaderTooLate() throw()
      {}
    }
    ;

    /*- end Exceptions thrown by a Logical thread ---------------------------------*/

    Logical(
            Transport & transport
            ,long       serialNo
            );
    
    Logical(
            Transport & transport
            );

    Logical(
            long        serialNo
            ,Transport& transport
            );


    virtual
    ~Logical();

    virtual
    bool
    selectCallback(
                   Packet &     firstPacket
                   )
    {
      return(true);
    }

    long
    serialNo() const;

    Transport &
    transport() const;

    class Writer
    {
    private:
      Writer(const Writer &);
      
      Writer &
      operator =(const Writer &);

    protected:
      Writer(){};

    public:
      ~Writer();

      size_t
      dataSize() const;

      void
      dataSize(size_t);

      void
      flush();
      
      void
      beginData();

      void
      granulePosition(
                      Position
                      );

      Position
      granulePosition() const;

      size_t
      pageSize() const;

      void
      pageSize(
               size_t
               );

      Writer &
      operator ++();

      Packet *
      operator->() const throw();

      Packet *
      packet() const throw()
      {
        return(operator->());
      }
    };

    class Reader
    {
    private:
      Reader(const Reader &);
      
      Reader &
      operator =(const Reader &);

    protected:
      Reader(){};

    public:
      ~Reader();

      Reader &
      operator ++();

      Reader &
      operator +=(PacketNo packets);

      Reader &
      operator =(Position position);

      bool
      ending() const;   

      Error
      transportError()  
        const;

      Position
      granulePosition()
        const;

      Packet *
      operator->() const throw();

      Packet *
      packet() const throw()
      {
        return(operator->());
      }
    };

    class PageWriter
    {
    private:
      PageWriter(const PageWriter &);
      
      PageWriter &
      operator =(const PageWriter &);

    protected:
      PageWriter(){};

    public:
      ~PageWriter();

      bool
      put(Page &);

      void
      doPut(Page &);

    };

    class PageReader
    {
    private:
      PageReader(const PageReader &);
      
      PageReader &
      operator =(const PageReader &);

    protected:
      PageReader(){};

    public:
      ~PageReader();

      Page *
      get();

      Page &
      doGet();
      
    };

    Writer &
    writer();

    PageWriter &
    pageWriter();


    PageReader &
    pageReader();

    Reader &
    reader();

  };
};
#endif

---