toppers/object.hpp

解説を見る。

/*
 *  TOPPERS/C++ API Template Library
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      C++ API Template Library
 *
 *  Copyright (C) 2004 by TAKAGI Nobuhisa
 *
 *  上記著作権者は，以下の (1)〜(4) の条件か，Free Software Foundation
 *  によって公表されている GNU General Public License の Version 2 に記
 *  述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
 *  を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
 *  利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
 *  含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
 *  接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
 *
 *  @(#) $Id: object.hpp,v 1.1.1.1 2004/04/14 09:30:29 takagi-n Exp $
 */

#ifndef TOPPERS_OBJECT_HPP_
#define TOPPERS_OBJECT_HPP_

#include <toppers/raw_stub.hpp>
#include <toppers/assert.hpp>
#include <toppers/diagnostics.hpp>

#ifndef TOPPERS_DEFAULT_STUB
#define TOPPERS_DEFAULT_STUB    raw_stub<>
#endif

namespace toppers
{

    template <ID Id>
    class object_id
    {
//      TOPPERS_STATIC_ASSERT(Id > 0);

    public:
        object_id() {}
        explicit object_id(ID id)
        {
            TOPPERS_ASSERT(id == Id);
        }
        void attach(ID) {}
        ID detach() { return Id; }
        ID id() const { return Id; }
    };

    template <>
    class object_id<0>
    {
        ER_ID id_;

    public:
        object_id() : id_(E_ID) {}
        explicit object_id(ID id) : id_(id) {}
        void attach(ID id) { id_ = id; }
        ID detach() { ID prev = id_; id_ = E_ID; return (ID)prev; }
        ID id() const { return (ID)id_; }
    };

    template <ID Id, object_type Object, class Stub>
    class object_controller;

    template <ID Id, class Stub>
    class object_controller<Id, obj_semaphore, Stub>
    {
    public:
        typedef t_csem creation;
        typedef t_rsem reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_sem(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_sem(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_sem(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_sem(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_sem(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_sem(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_eventflag, Stub>
    {
    public:
        typedef t_cflg creation;
        typedef t_rflg reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_flg(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_flg(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_flg(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_flg(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_flg(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_flg(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_dataqueue, Stub>
    {
    public:
        typedef t_cdtq creation;
        typedef t_rdtq reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_dtq(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_dtq(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_dtq(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_dtq(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_dtq(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_dtq(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_mailbox, Stub>
    {
    public:
        typedef t_cmbx creation;
        typedef t_rmbx reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mbx(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mbx(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mbx(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mbx(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_mbx(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_mbx(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_mutex, Stub>
    {
    public:
        typedef t_cmtx creation;
        typedef t_rmtx reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mtx(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mtx(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mtx(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mtx(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_mtx(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_mtx(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_messagebuffer, Stub>
    {
    public:
        typedef t_cmbf creation;
        typedef t_rmbf reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mbf(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mbf(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mbf(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mbf(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_mbf(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_mbf(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_rendezvousport, Stub>
    {
    public:
        typedef t_cpor creation;
        typedef t_rpor reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_por(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_por(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_por(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_por(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_por(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_por(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_fmempool, Stub>
    {
    public:
        typedef t_cmpf creation;
        typedef t_rmpf reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mpf(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mpf(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mpf(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mpf(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_mpf(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_mpf(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_vmempool, Stub>
    {
    public:
        typedef t_cmpl creation;
        typedef t_rmpl reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mpl(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mpl(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_mpl(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_mpl(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_mpl(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_mpl(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_task, Stub>
    {
    public:
        typedef t_ctsk creation;
        typedef t_rtsk reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_tsk(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_tsk(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_tsk(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_tsk(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_tsk(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_tsk(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_cyclichandler, Stub>
    {
    public:
        typedef t_ccyc creation;
        typedef t_rcyc reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_cyc(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_cyc(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_cyc(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_cyc(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_cyc(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_cyc(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_alarmhandler, Stub>
    {
    public:
        typedef t_calm creation;
        typedef t_ralm reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_alm(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_alm(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_alm(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_alm(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_alm(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_alm(objid.id(), pk_robj);
        }
    };

    template <ID Id, class Stub>
    class object_controller<Id, obj_isr, Stub>
    {
    public:
        typedef t_cisr creation;
        typedef t_risr reference;

        static ER create(object_id<Id>& objid, creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_isr(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_isr(objid.id(), pk_cobj);
        }
        static ER create(object_id<Id>& objid, const creation* pk_cobj)
        {
            if (Id == 0)
            {
                ER_ID erid = Stub::stub_acre_isr(pk_cobj);
                if (erid > 0)
                {
                    objid.attach(erid);
                    erid = 0;
                }
                return static_cast<ER>(erid);
            }
            return Stub::stub_cre_isr(objid.id(), pk_cobj);
        }
        static ER destroy(object_id<Id>& objid)
        {
            ER ercd = Stub::stub_del_isr(objid.id());
            if (ercd == E_OK)
                objid.detach();
            return ercd;
        }
        static ER refer(const object_id<Id>& objid, reference* pk_robj)
        {
            return Stub::stub_ref_isr(objid.id(), pk_robj);
        }
    };

}

#endif  // ! TOPPERS_OBJECT_HPP_

---

• Copyright © 2004 by TAKAGI Nobuhisa
• 本ソフトウェアはTOPPERSライセンスに基づいて配布されています。
• TRONは"The Real-time Operating system Nucleus"の略称です。
• ITRONは"Industrial TRON"の略称です。
• μITRONは"Micro Industrial TRON"の略称です。
• TRON、ITRON、およびμITRONは、特定の商品ないしは商品群を指す名称ではありません。
• TOPPERSは"Toyohashi OPen Platform for Embedded Real-time Systems"の略称、JSPは"Just Standard Profile"の略称です。
• 本ページ中の商品名は，各社の商標または登録商標です。