LCOV - app.info - other-licenses/snappy/src/snappy-sinksource.h

LCOV - code coverage report
| Current view: | directory - other-licenses/snappy/src - snappy-sinksource.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 5 | 5 | 100.0 %
| Date: | 2012-06-02 | Functions: | 5 | 5 | 100.0 %

           1                 : // Copyright 2011 Google Inc. All Rights Reserved.
           2                 : //
           3                 : // Redistribution and use in source and binary forms, with or without
           4                 : // modification, are permitted provided that the following conditions are
           5                 : // met:
           6                 : //
           7                 : //     * Redistributions of source code must retain the above copyright
           8                 : // notice, this list of conditions and the following disclaimer.
           9                 : //     * Redistributions in binary form must reproduce the above
          10                 : // copyright notice, this list of conditions and the following disclaimer
          11                 : // in the documentation and/or other materials provided with the
          12                 : // distribution.
          13                 : //     * Neither the name of Google Inc. nor the names of its
          14                 : // contributors may be used to endorse or promote products derived from
          15                 : // this software without specific prior written permission.
          16                 : //
          17                 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          18                 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          19                 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          20                 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          21                 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          22                 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          23                 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          24                 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          25                 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          26                 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          27                 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          28                 :
          29                 : #ifndef UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
          30                 : #define UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
          31                 :
          32                 : #include <stddef.h>
          33                 :
          34                 :
          35                 : namespace snappy {
          36                 :
          37                 : // A Sink is an interface that consumes a sequence of bytes.
          38                 : class Sink {
          39                 :  public:
          40            1837 :   Sink() { }
          41                 :   virtual ~Sink();
          42                 :
          43                 :   // Append "bytes[0,n-1]" to this.
          44                 :   virtual void Append(const char* bytes, size_t n) = 0;
          45                 :
          46                 :   // Returns a writable buffer of the specified length for appending.
          47                 :   // May return a pointer to the caller-owned scratch buffer which
          48                 :   // must have at least the indicated length.  The returned buffer is
          49                 :   // only valid until the next operation on this Sink.
          50                 :   //
          51                 :   // After writing at most "length" bytes, call Append() with the
          52                 :   // pointer returned from this function and the number of bytes
          53                 :   // written.  Many Append() implementations will avoid copying
          54                 :   // bytes if this function returned an internal buffer.
          55                 :   //
          56                 :   // If a non-scratch buffer is returned, the caller may only pass a
          57                 :   // prefix of it to Append().  That is, it is not correct to pass an
          58                 :   // interior pointer of the returned array to Append().
          59                 :   //
          60                 :   // The default implementation always returns the scratch buffer.
          61                 :   virtual char* GetAppendBuffer(size_t length, char* scratch);
          62                 :
          63                 :  private:
          64                 :   // No copying
          65                 :   Sink(const Sink&);
          66                 :   void operator=(const Sink&);
          67                 : };
          68                 :
          69                 : // A Source is an interface that yields a sequence of bytes
          70                 : class Source {
          71                 :  public:
          72            3807 :   Source() { }
          73                 :   virtual ~Source();
          74                 :
          75                 :   // Return the number of bytes left to read from the source
          76                 :   virtual size_t Available() const = 0;
          77                 :
          78                 :   // Peek at the next flat region of the source.  Does not reposition
          79                 :   // the source.  The returned region is empty iff Available()==0.
          80                 :   //
          81                 :   // Returns a pointer to the beginning of the region and store its
          82                 :   // length in *len.
          83                 :   //
          84                 :   // The returned region is valid until the next call to Skip() or
          85                 :   // until this object is destroyed, whichever occurs first.
          86                 :   //
          87                 :   // The returned region may be larger than Available() (for example
          88                 :   // if this ByteSource is a view on a substring of a larger source).
          89                 :   // The caller is responsible for ensuring that it only reads the
          90                 :   // Available() bytes.
          91                 :   virtual const char* Peek(size_t* len) = 0;
          92                 :
          93                 :   // Skip the next n bytes.  Invalidates any buffer returned by
          94                 :   // a previous call to Peek().
          95                 :   // REQUIRES: Available() >= n
          96                 :   virtual void Skip(size_t n) = 0;
          97                 :
          98                 :  private:
          99                 :   // No copying
         100                 :   Source(const Source&);
         101                 :   void operator=(const Source&);
         102                 : };
         103                 :
         104                 : // A Source implementation that yields the contents of a flat array
         105                 : class ByteArraySource : public Source {
         106                 :  public:
         107            3807 :   ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { }
         108                 :   virtual ~ByteArraySource();
         109                 :   virtual size_t Available() const;
         110                 :   virtual const char* Peek(size_t* len);
         111                 :   virtual void Skip(size_t n);
         112                 :  private:
         113                 :   const char* ptr_;
         114                 :   size_t left_;
         115                 : };
         116                 :
         117                 : // A Sink implementation that writes to a flat array without any bound checks.
         118                 : class UncheckedByteArraySink : public Sink {
         119                 :  public:
         120            1837 :   explicit UncheckedByteArraySink(char* dest) : dest_(dest) { }
         121                 :   virtual ~UncheckedByteArraySink();
         122                 :   virtual void Append(const char* data, size_t n);
         123                 :   virtual char* GetAppendBuffer(size_t len, char* scratch);
         124                 :
         125                 :   // Return the current output pointer so that a caller can see how
         126                 :   // many bytes were produced.
         127                 :   // Note: this is not a Sink method.
         128            1837 :   char* CurrentDestination() const { return dest_; }
         129                 :  private:
         130                 :   char* dest_;
         131                 : };
         132                 :
         133                 :
         134                 : }
         135                 :
         136                 : #endif  // UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_

Generated by: LCOV version 1.7