Parcel.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005 Palmsource, Inc.
 * 
 * This software is licensed as described in the file LICENSE, which
 * you should have received as part of this distribution. The terms
 * are also available at http://www.openbinder.org/license.html.
 * 
 * This software consists of voluntary contributions made by many
 * individuals. For the exact contribution history, see the revision
 * history and logs, available at http://www.openbinder.org
 */

#ifndef _SUPPORT_PARCEL_H
#define _SUPPORT_PARCEL_H

#include <support/SupportDefs.h>
#include <support/IBinder.h>
#include <support/IByteStream.h>
#include <support/ITextStream.h>
#include <support/Vector.h>

#if TARGET_HOST == TARGET_HOST_PALMOS
#include <Kernel.h>
#include <support/KeyID.h>
#endif

BNS(namespace palmos {)
BNS(namespace support {)


class IBinder;

struct binder_ipc_info;
struct flat_binder_object;

struct small_flat_data;
struct large_flat_header;

/*-------------------------------------------------------------*/

class SParcel
{
    public:
        static  SParcel*        GetParcel(void);
        static  void            PutParcel(SParcel *);
    
        typedef void            (*free_func)(   const void* data,
                                                ssize_t len,
                                                void* context);
        typedef status_t        (*reply_func)(  const SParcel& buffer,
                                                void* context);
    
                                SParcel(ssize_t bufferSize = -1);
                                SParcel(sptr<IByteOutput> output,
                                        sptr<IByteInput> input,
                                        sptr<IByteSeekable> seek,
                                        ssize_t bufferSize = -1);
                                SParcel(reply_func replyFunc,
                                        void* replyContext = NULL);
                                SParcel(const void* data, ssize_t len,
                                        free_func freeFunc = NULL,
                                        void* freeContext = NULL,
                                        reply_func replyFunc = NULL,
                                        void* replyContext = NULL);
        virtual                 ~SParcel();
    
                const void*     Data() const;
                
                void*           EditData();
                
                ssize_t         Length() const;
                
                ssize_t         Avail() const;
                

                ssize_t         AvailBinders() const;
                
                status_t        ErrorCheck() const;
                
                bool            IsCacheable() const;

                void            Reference(  const void* data, ssize_t len,
                                            free_func freeFunc = NULL,
                                            void* context = NULL);
                
                status_t        Copy(const void* data, ssize_t len);
                
                status_t        Copy(const SParcel& src);
                
                status_t        Reserve(ssize_t len);
                
                void*           Alloc(ssize_t len);
                
                void*           ReAlloc(ssize_t len);

                void            Reset();
                
                status_t        SetValues(const SValue* value1, ...);
                
                int32_t         CountValues() const;
                
                int32_t         GetValues(int32_t maxCount, SValue* outValues) const;
                
                void            Transfer(SParcel* src);
                

                bool            ReplyRequested() const;
                status_t        Reply();

                void            Free();
                
                off_t           Position() const;
                void            SetPosition(off_t pos);
                status_t        SetLength(ssize_t len);
                


                ssize_t         WriteTypeHeader(type_code type, size_t amount);

                ssize_t         WriteTypeHeaderAndData(type_code type, const void *data, size_t amount);
                

                ssize_t         MarshalFixedData(type_code type, const void *data, size_t amount);

                status_t        UnmarshalFixedData(type_code type, void *data, size_t amount);

                ssize_t         WriteSmallData(uint32_t packedType, uint32_t packedData);
                ssize_t         WriteSmallData(const small_flat_data& flat);

                ssize_t         WriteLargeData(uint32_t packedType, size_t length, const void* data);
                ssize_t         WriteBinder(const flat_binder_object& val);

                ssize_t         ReadSmallData(small_flat_data* out);


                ssize_t         ReadSmallDataOrObject(small_flat_data* out, const void* who);

                ssize_t         ReadFlatBinderObject(flat_binder_object* out);
                

                ssize_t         WriteTypedData(type_code type, const void *data);

                status_t        ReadTypedData(type_code type, void *data);

        static  ssize_t         TypedDataSize(type_code type, const void *data);
                

                ssize_t         WriteValue(const SValue& val);

                SValue          ReadValue();


                status_t        SkipValue();



        static  ssize_t         BinderSize(const sptr<IBinder>& val);
        static  ssize_t         WeakBinderSize(const wptr<IBinder>& val);

                ssize_t         WriteBinder(const sptr<IBinder>& val);
                ssize_t         WriteWeakBinder(const wptr<IBinder>& val);
                ssize_t         WriteBinder(const small_flat_data& val);
#if TARGET_HOST == TARGET_HOST_PALMOS
                ssize_t         WriteKeyID(const sptr<SKeyID>& val);
#endif

                
                sptr<IBinder>   ReadBinder();
                wptr<IBinder>   ReadWeakBinder();
#if TARGET_HOST == TARGET_HOST_PALMOS
                sptr<SKeyID>    ReadKeyID();
#endif



                ssize_t         Write(const void* buffer, size_t amount);
                void *          WriteInPlace(size_t amount); 
                ssize_t         WritePadded(const void* buffer, size_t amount); 
                ssize_t         WritePadding(); 
                ssize_t         WriteBool(bool val);
                ssize_t         WriteInt8(int8_t val);
                ssize_t         WriteInt16(int16_t val);
                ssize_t         WriteInt32(int32_t val);
                ssize_t         WriteInt64(int64_t val);
                ssize_t         WriteUInt8(uint8_t val) {return WriteInt8((int8_t)val);}
                ssize_t         WriteUInt16(uint16_t val) {return WriteInt16((int16_t)val);}
                ssize_t         WriteUInt32(uint32_t val) {return WriteInt32((int32_t)val);}
                ssize_t         WriteUInt64(uint64_t val) {return WriteInt64((int64_t)val);}
                ssize_t         WriteFloat(float val);
                ssize_t         WriteDouble(double val);
                ssize_t         WriteString(const SString& val);
                ssize_t         WriteString(const char* val);

                ssize_t         Read(void* buffer, size_t amount);
                const void*     ReadInPlace(size_t amount);
                ssize_t         ReadPadded(void* buffer, size_t amount);
                ssize_t         Drain(size_t amount);
                ssize_t         DrainPadding(); 
                bool            ReadBool();
                int8_t          ReadInt8();
                int16_t         ReadInt16();
                int32_t         ReadInt32();
                int64_t         ReadInt64();
                uint8_t         ReadUInt8() {return (uint8_t)ReadInt8();}
                uint16_t        ReadUInt16() {return (uint16_t)ReadInt16();}
                uint32_t        ReadUInt32() {return (uint32_t)ReadInt32();}
                uint64_t        ReadUInt64() {return (uint64_t)ReadInt64();}
                float           ReadFloat();
                double          ReadDouble();
                SString         ReadString();
                
                ssize_t         Flush();
                ssize_t         Sync();
                

                const void*     BinderOffsetsData() const;
                size_t          BinderOffsetsLength() const;
#if TARGET_HOST == TARGET_HOST_PALMOS
                status_t        SetBinderOffsets(   binder_ipc_info const * const offsets,
                                                    size_t count,
                                                    bool takeRefs = true);
#else
                status_t        SetBinderOffsets(   const void* offsets,
                                                    size_t length,
                                                    bool takeRefs = true);
#endif

                
                void            PrintToStream(const sptr<ITextOutput>& io, uint32_t flags = 0) const;
    
    protected:
    
        virtual ssize_t         WriteBuffer(const void* buffer, size_t len) const;
        virtual ssize_t         ReadBuffer(void* buffer, size_t len);
                                                
    private:
                                SParcel(const SParcel& o);
                SParcel&        operator=(const SParcel& o);
                
                void            do_free();
                void            acquire_binders();
                void            release_binders();
                ssize_t         finish_write(ssize_t amt);
                
                uint8_t*            m_data;
                ssize_t             m_length;
                ssize_t             m_avail;
                
                free_func           m_free;
                void*               m_freeContext;
                
                reply_func          m_reply;
                void*               m_replyContext;
                
                off_t               m_base;
                ssize_t             m_pos;
                sptr<IByteOutput>   m_out;
                sptr<IByteInput>    m_in;
                sptr<IByteSeekable> m_seek;
                
                uint32_t                m_dirty : 1;
                uint32_t                m_ownsBinders : 1;
                uint32_t                m_reserved: 30;
                
                SVector<size_t>     m_binders;
                
                uint8_t             m_inline[32];
};

_IMPEXP_SUPPORT const sptr<ITextOutput>& operator<<(const sptr<ITextOutput>& io, const SParcel& value);

/*-------------------------------------------------------------*/

BNS(} }) // namespace palmos::support

#endif  // _SUPPORT_PARCEL_H

---

Generated on Wed Dec 28 22:33:28 2005 by Doxygen 1.4.4 for OpenBinder Documentation Version 1.0

PalmSource, Inc. © 2005