1 /*

     2  * Copyright (C) 2009 Apple Inc. All Rights Reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    24  */

    25 

    26 #ifndef ByteArray_h

    27 #define ByteArray_h

    28 

    29 #include <wtf/PassRefPtr.h>

    30 #include <wtf/RefCounted.h>

    31 

    32 namespace WTF {

    33     class ByteArray : public RefCountedBase {

    34     public:

    35         unsigned length() const { return m_size; }

    36 

    37         void set(unsigned index, double value)

    38         {

    39             if (index >= m_size)

    40                 return;

    41             if (!(value > 0)) // Clamp NaN to 0

    42                 value = 0;

    43             else if (value > 255)

    44                 value = 255;

    45             m_data[index] = static_cast<unsigned char>(value + 0.5);

    46         }

    47 

    48         void set(unsigned index, unsigned char value)

    49         {

    50             if (index >= m_size)

    51                 return;

    52             m_data[index] = value;

    53         }

    54 

    55         bool get(unsigned index, unsigned char& result) const

    56         {

    57             if (index >= m_size)

    58                 return false;

    59             result = m_data[index];

    60             return true;

    61         }

    62 

    63         unsigned char get(unsigned index) const

    64         {

    65             ASSERT(index < m_size);

    66             return m_data[index];

    67         }

    68 

    69         unsigned char* data() { return m_data; }

    70 

    71         void deref()

    72         {

    73             if (derefBase()) {

    74                 // We allocated with new unsigned char[] in create(),

    75                 // and then used placement new to construct the object.

    76                 this->~ByteArray();

    77                 delete[] reinterpret_cast<unsigned char*>(this);

    78             }

    79         }

    80 

    81         static PassRefPtr<ByteArray> create(size_t size);

    82 

    83     private:

    84         ByteArray(size_t size)

    85             : m_size(size)

    86         {

    87         }

    88         size_t m_size;

    89         unsigned char m_data[sizeof(size_t)];

    90     };

    91 }

    92 

    93 #endif