The Tor Browser / file revision

 /*

  * Copyright 2006 The Android Open Source Project

  *

  * Use of this source code is governed by a BSD-style license that can be

  * found in the LICENSE file.

  */

 #ifndef SkMetaData_DEFINED

 #define SkMetaData_DEFINED

 #include "SkScalar.h"

 class SkRefCnt;

 class SK_API SkMetaData {

 public:

     /**

      *  Used to manage the life-cycle of a ptr in the metadata. This is option

      *  in setPtr, and is only invoked when either copying one metadata to

      *  another, or when the metadata is destroyed.

      *

      *  setPtr(name, ptr, proc) {

      *      fPtr = proc(ptr, true);

      *  }

      *

      *  copy: A = B {

      *      A.fPtr = B.fProc(B.fPtr, true);

      *  }

      *

      *  ~SkMetaData {

      *      fProc(fPtr, false);

      *  }

      */

     typedef void* (*PtrProc)(void* ptr, bool doRef);

     /**

      *  Implements PtrProc for SkRefCnt pointers

      */

     static void* RefCntProc(void* ptr, bool doRef);

     SkMetaData();

     SkMetaData(const SkMetaData& src);

     ~SkMetaData();

     SkMetaData& operator=(const SkMetaData& src);

     void reset();

     bool findS32(const char name[], int32_t* value = NULL) const;

     bool findScalar(const char name[], SkScalar* value = NULL) const;

     const SkScalar* findScalars(const char name[], int* count,

                                 SkScalar values[] = NULL) const;

     const char* findString(const char name[]) const;

     bool findPtr(const char name[], void** value = NULL, PtrProc* = NULL) const;

     bool findBool(const char name[], bool* value = NULL) const;

     const void* findData(const char name[], size_t* byteCount = NULL) const;

     bool hasS32(const char name[], int32_t value) const {

         int32_t v;

         return this->findS32(name, &v) && v == value;

     }

     bool hasScalar(const char name[], SkScalar value) const {

         SkScalar v;

         return this->findScalar(name, &v) && v == value;

     }

     bool hasString(const char name[], const char value[]) const {

         const char* v = this->findString(name);

         return  (v == NULL && value == NULL) ||

                 (v != NULL && value != NULL && !strcmp(v, value));

     }

     bool hasPtr(const char name[], void* value) const {

         void* v;

         return this->findPtr(name, &v) && v == value;

     }

     bool hasBool(const char name[], bool value) const {

         bool    v;

         return this->findBool(name, &v) && v == value;

     }

     bool hasData(const char name[], const void* data, size_t byteCount) const {

         size_t len;

         const void* ptr = this->findData(name, &len);

         return NULL != ptr && len == byteCount && !memcmp(ptr, data, len);

     }

     void setS32(const char name[], int32_t value);

     void setScalar(const char name[], SkScalar value);

     SkScalar* setScalars(const char name[], int count, const SkScalar values[] = NULL);

     void setString(const char name[], const char value[]);

     void setPtr(const char name[], void* value, PtrProc proc = NULL);

     void setBool(const char name[], bool value);

     // the data is copied from the input pointer.

     void setData(const char name[], const void* data, size_t byteCount);

     bool removeS32(const char name[]);

     bool removeScalar(const char name[]);

     bool removeString(const char name[]);

     bool removePtr(const char name[]);

     bool removeBool(const char name[]);

     bool removeData(const char name[]);

     // helpers for SkRefCnt

     bool findRefCnt(const char name[], SkRefCnt** ptr = NULL) {

         return this->findPtr(name, reinterpret_cast<void**>(ptr));

     }

     bool hasRefCnt(const char name[], SkRefCnt* ptr) {

         return this->hasPtr(name, ptr);

     }

     void setRefCnt(const char name[], SkRefCnt* ptr) {

         this->setPtr(name, ptr, RefCntProc);

     }

     bool removeRefCnt(const char name[]) {

         return this->removePtr(name);

     }

     enum Type {

         kS32_Type,

         kScalar_Type,

         kString_Type,

         kPtr_Type,

         kBool_Type,

         kData_Type,

         kTypeCount

     };

     struct Rec;

     class Iter;

     friend class Iter;

     class Iter {

     public:

         Iter() : fRec(NULL) {}

         Iter(const SkMetaData&);

         /** Reset the iterator, so that calling next() will return the first

             data element. This is done implicitly in the constructor.

         */

         void reset(const SkMetaData&);

         /** Each time next is called, it returns the name of the next data element,

             or null when there are no more elements. If non-null is returned, then the

             element's type is returned (if not null), and the number of data values

             is returned in count (if not null).

         */

         const char* next(Type*, int* count);

     private:

         Rec* fRec;

     };

 public:

     struct Rec {

         Rec*        fNext;

         uint16_t    fDataCount; // number of elements

         uint8_t     fDataLen;   // sizeof a single element

         uint8_t     fType;

         const void* data() const { return (this + 1); }

         void*       data() { return (this + 1); }

         const char* name() const { return (const char*)this->data() + fDataLen * fDataCount; }

         char*       name() { return (char*)this->data() + fDataLen * fDataCount; }

         static Rec* Alloc(size_t);

         static void Free(Rec*);

     };

     Rec*    fRec;

     const Rec* find(const char name[], Type) const;

     void* set(const char name[], const void* data, size_t len, Type, int count);

     bool remove(const char name[], Type);

 };

 #endif