Home | History | Annotate | Download | only in CoreIPC 
      1 /*
      2  * Copyright (C) 2010 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. AND ITS CONTRIBUTORS ``AS IS''
     14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
     15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
     17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     23  * THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #ifndef ArgumentEncoder_h
     27 #define ArgumentEncoder_h
     28 
     29 #include "ArgumentCoder.h"
     30 #include "Attachment.h"
     31 #include <wtf/PassOwnPtr.h>
     32 #include <wtf/TypeTraits.h>
     33 #include <wtf/Vector.h>
     34 
     35 namespace CoreIPC {
     36 
     37 class ArgumentEncoder;
     38 
     39 class ArgumentEncoder {
     40 public:
     41     static PassOwnPtr<ArgumentEncoder> create(uint64_t destinationID);
     42     ~ArgumentEncoder();
     43 
     44     void encodeBytes(const uint8_t*, size_t);
     45 
     46     void encodeBool(bool);
     47     void encodeUInt32(uint32_t);
     48     void encodeUInt64(uint64_t);
     49     void encodeInt32(int32_t);
     50     void encodeInt64(int64_t);
     51     void encodeFloat(float);
     52     void encodeDouble(double);
     53 
     54     template<typename T> void encodeEnum(T t)
     55     {
     56         COMPILE_ASSERT(sizeof(T) <= sizeof(uint64_t), enum_type_must_not_be_larger_than_64_bits);
     57 
     58         encodeUInt64(static_cast<uint64_t>(t));
     59     }
     60 
     61     // Generic type encode function.
     62     template<typename T> void encode(const T& t)
     63     {
     64         ArgumentCoder<T>::encode(this, t);
     65     }
     66 
     67     uint8_t* buffer() const { return m_buffer; }
     68     size_t bufferSize() const { return m_bufferSize; }
     69 
     70     void addAttachment(const Attachment&);
     71     Vector<Attachment> releaseAttachments();
     72 
     73 #ifndef NDEBUG
     74     void debug();
     75 #endif
     76 
     77 private:
     78     explicit ArgumentEncoder(uint64_t destinationID);
     79     uint8_t* grow(unsigned alignment, size_t size);
     80 
     81     uint8_t* m_buffer;
     82     uint8_t* m_bufferPointer;
     83 
     84     size_t m_bufferSize;
     85     size_t m_bufferCapacity;
     86 
     87     Vector<Attachment> m_attachments;
     88 };
     89 
     90 template<> inline void ArgumentEncoder::encode(const bool& n)
     91 {
     92     encodeBool(n);
     93 }
     94 
     95 template<> inline void ArgumentEncoder::encode(const uint32_t& n)
     96 {
     97     encodeUInt32(n);
     98 }
     99 
    100 template<> inline void ArgumentEncoder::encode(const uint64_t& n)
    101 {
    102     encodeUInt64(n);
    103 }
    104 
    105 template<> inline void ArgumentEncoder::encode(const int32_t& n)
    106 {
    107     encodeInt32(n);
    108 }
    109 
    110 template<> inline void ArgumentEncoder::encode(const int64_t& n)
    111 {
    112     encodeInt64(n);
    113 }
    114 
    115 template<> inline void ArgumentEncoder::encode(const float& n)
    116 {
    117     encodeFloat(n);
    118 }
    119 
    120 template<> inline void ArgumentEncoder::encode(const double& n)
    121 {
    122     encodeDouble(n);
    123 }
    124 
    125 } // namespace CoreIPC
    126 
    127 #endif // ArgumentEncoder_h
    128