Package.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_PACKAGE_H
#define _SUPPORT_PACKAGE_H

#include <support/KeyedVector.h>
#include <support/Locker.h>
#include <support/String.h>
#include <support/Value.h>

#if _SUPPORTS_NAMESPACE
namespace palmos {
namespace support {
#endif

#if (defined(__GNUC__))
#define ATTRIBUTE_VISIBILITY_HIDDEN __attribute__ ((visibility("hidden")))
#else
#define ATTRIBUTE_VISIBILITY_HIDDEN
#endif

#if TARGET_HOST == TARGET_HOST_PALMOS
#include <CmnLaunchCodes.h>
#include <DataMgr.h>
#else
#define sysPackageLaunchAttachImage             71
#endif

class BSharedObject;

struct SysPackageLaunchAttachImageType
{
      size_t                  size;
      sptr<BSharedObject>     image;
};

typedef void    (*attach_func)(const sptr<BSharedObject>& image);


/*---------------------------------------------------------------*/
/*----- SPackage ------------------------------------------------*/
class SPackage 
{
public:
    SPackage();
    SPackage(const SString& name);
    SPackage(const SValue& value, status_t* err=NULL);
    SValue AsValue();

    ~SPackage();

    status_t StatusCheck();
    SString Name();
    SString Path();
            
    sptr<IByteInput> OpenResource(const SString& fileName, const SString& locale = SString::EmptyString());
    
    SString LoadString(const SString& key, const SString& locale = SString::EmptyString());
    SString LoadString(uint32_t index, const SString& locale = SString::EmptyString());

private:
    class MemoryMap : public virtual SAtom
    {
    public:
        MemoryMap(const SString& path);

        void* Buffer();
        size_t Size();
    protected:
        ~MemoryMap();

    private:
        int m_fd;
        void* m_buffer; 
        size_t m_length;
    };

    class Data : public virtual SAtom
    {
    public:
        Data(const SString& name, const SString& path);
        
        SString Name();
        SString Path();
        SString ResourcePath();
        
        SString LoadString(const SString& key, const SString& locale);
        SString LoadString(uint32_t index, const SString& locale);

    protected:
        virtual ~Data();

    private:    
        char* get_buffer_for(const SString& locale);
        
        SLocker m_lock;
        SString m_name;
        SString m_path;
        SString m_resourcePath;

        SKeyedVector<SString, sptr<SPackage::MemoryMap> > m_maps;
    };

    class Pool
    {
    public:
        Pool();
        
        sptr<SPackage::Data> DataFor(const SString& pkgName);

    private:
        SLocker m_lock;
        SKeyedVector<SString, wptr<SPackage::Data> > m_packages;
    };


    static SPackage::Pool g_pool;
    sptr<Data> m_data;
};

extern const SPackage B_NO_PACKAGE;


/*---------------------------------------------------------------*/
/*----- BSharedObject -------------------------------------------*/
class BSharedObject : public virtual SAtom
{
public:

                            BSharedObject(const SValue& src, const SPackage &package, attach_func attach = NULL);

            //              BSharedObject(const image_id image);

            image_id        ID() const;
            SValue          Source() const;
            SString         File() const;


            status_t        GetSymbolFor(   const char* name,
                                            int32_t sclass,
                                            void** outPtr) const;

            status_t        GetSymbolAt(    int32_t index,
                                            SString* outName,
                                            int32_t* outSClass,
                                            void** outPtr) const;


            void            Detach();

            inline SPackage Package() { return m_package; }

protected:
    virtual                 ~BSharedObject();
    virtual void            InitAtom();

private:
            void            close_resource();

            const SValue    m_source;
            SValue          m_extra;
            image_id        m_handle;
            attach_func     m_attachFunc;
            SPackage        m_package;

private:

    // copy constructor not supported
    BSharedObject( const BSharedObject& rhs );

    // operator= not supported
    BSharedObject& operator=( const BSharedObject& rhs );
};


/*-----------------------------------------------------------*/
/*----- SPackageSptr ----------------------------------------*/

class SPackageSptr
{
public:

                                    SPackageSptr()
                                     ATTRIBUTE_VISIBILITY_HIDDEN
                                     ;

    inline                          ~SPackageSptr()
                                     ATTRIBUTE_VISIBILITY_HIDDEN
                                     ;

    inline  const sptr<BSharedObject>&  SharedObject() const ATTRIBUTE_VISIBILITY_HIDDEN;
    inline  SPackage                    Package() const ATTRIBUTE_VISIBILITY_HIDDEN;

    sptr<IByteInput> OpenResource(const SString& fileName, const SString& locale = SString::EmptyString()) const ATTRIBUTE_VISIBILITY_HIDDEN;
    
    SString LoadString(const SString& key, const SString& locale = SString::EmptyString()) const ATTRIBUTE_VISIBILITY_HIDDEN;
    SString LoadString(uint32_t index, const SString& locale = SString::EmptyString()) const ATTRIBUTE_VISIBILITY_HIDDEN;
    
    // XXX This are old APIs from Cobalt.
    
    inline  sptr<IByteInput>        OpenResource(uint32_t type, int32_t id) const ATTRIBUTE_VISIBILITY_HIDDEN;
    inline  SString                 LoadString(int32_t id, int32_t index = 0) const ATTRIBUTE_VISIBILITY_HIDDEN;

private:
            sptr<BSharedObject>     m_so;
};

inline SPackageSptr::~SPackageSptr()
{
}

inline const sptr<BSharedObject>& SPackageSptr::SharedObject() const
{
    return m_so;
}
inline SPackage SPackageSptr::Package() const
{
    return m_so->Package();
}

inline sptr<IByteInput> SPackageSptr::OpenResource(const SString& fileName, const SString& locale) const
{
    return m_so->Package().OpenResource(fileName, locale);
}

inline SString SPackageSptr::LoadString(const SString& key, const SString& locale) const
{
    return m_so->Package().LoadString(key, locale);
}

inline SString SPackageSptr::LoadString(uint32_t index, const SString& locale) const
{
    return m_so->Package().LoadString(index, locale);
}

inline sptr<IByteInput> SPackageSptr::OpenResource(uint32_t type, int32_t id) const
{
    return NULL;
}
inline SString SPackageSptr::LoadString(int32_t id, int32_t index) const
{
    return SString();
}

typedef SPackageSptr SDontForgetThis;

#if _SUPPORTS_NAMESPACE
} } // namespace palmos::support
#endif

#endif

---

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

PalmSource, Inc. © 2005