ページの先頭行へ戻る
Interstage Application Server アプリケーション作成ガイド(コンポーネントトランザクションサービス編)
第6章 C++言語の提供クラス > 6.1 IDL定義を元に生成されるクラス > 6.1.2 構造データ型のマッピング形態
前次

6.1.2 構造データ型のマッピング形態

  IDL定義で構造データ型を記述した場合、データ操作用のクラスおよびメンバ関数が生成されます。

  構造データ型には、以下の３つがあります。

6.1.2.1 構造体型

(1)マッピング

  IDL言語で構造体型structを指定した場合、C++言語でもstructでデータを宣言します。

  構造体を宣言すると、上記のように“構造体名_var”クラスが生成されます。

(2)メンバ変数/メンバ関数

(3)領域獲得/解放

固定長データ
可変長データ

6.1.2.2 配列型

(1)マッピング

  IDL言語で配列を指定した場合、C++言語でも配列でデータを宣言します。

(2)メンバ変数/メンバ関数

(3)配列_varクラスのメンバ変数/メンバ関数

  配列を宣言すると、“配列名_var”クラスが生成されます。

(4)領域獲得/解放

固定長データ
可変長データ

6.1.2.3 シーケンス型

(1)マッピング

  IDL言語でシーケンス型sequenceを指定した場合、C++言語では_maximum（最大長）、_length（シーケンス長）、_buffer（バッファポインタ）をprivateデータに持ったC++のクラスにマッピングします。

IDL定義
module M1 {
        interface I1 {
                typedef sequence <long> SequenceLong;
・・・
        };
    interface I2 {
        typedef sequence <string> SequenceStr;
        ・・・
    };
    interface I3 {
        typedef sequence <string,10> BSequenceStr;
        ・・・
    };

};
トランザクションアプリケーション用ヘッダファイル
class   M1
{
public:
    class   I1 : public virtual TD
    {
    public:
        class SequenceLong
        {
        public:
            SequenceLong();
            SequenceLong( CORBA::ULong );
            SequenceLong( CORBA::ULong max, CORBA::ULong length,
                 CORBA::Long *data, CORBA::Boolean release = CORBA_TRUE );
            SequenceLong( const SequenceLong &s );
            ~SequenceLong();

            static CORBA::Long *allocbuf( CORBA::ULong );
            static void freebuf( CORBA::Long* );

            SequenceLong &operator=( const SequenceLong &s );

            CORBA::ULong maximum() const;

            void length( CORBA::ULong );
            CORBA::ULong length() const;

            CORBA::Long &operator[]( CORBA::ULong index );
            const CORBA::Long &operator[]( CORBA::ULong index ) const;

        private:
            CORBA::ULong _maximum;
            CORBA::ULong _length;
            CORBA::Long *_buffer;
            CORBA::Boolean _release;
            CORBA::Long wkrtn;
        };

        class SequenceLong_var
        {
        public:
            SequenceLong_var();
            SequenceLong_var( SequenceLong_ptr );
            SequenceLong_var( const SequenceLong_var & );
            ~SequenceLong_var();

            SequenceLong_var &operator=( SequenceLong_ptr );
            SequenceLong_var &operator=( const SequenceLong_var & );

            operator SequenceLong_ptr() const;
            operator SequenceLong_ptr&();
            SequenceLong_ptr operator->() const;

            CORBA::Long &operator[]( CORBA::ULong );
            const CORBA::Long &operator[]( CORBA::ULong ) const;
            protected:
            SequenceLong    *_ptr;
            CORBA::Long wkrtn;
        };
    };
    class   I2 : public virtual TD
    {
    public:
        class SequenceStr
        {
        public:
            SequenceStr();
            SequenceStr( CORBA::ULong );
            SequenceStr( CORBA::ULong max, CORBA::ULong length,
                TD::String_var *data, CORBA::Boolean release = CORBA_TRUE );
            SequenceStr( const SequenceStr &s );
            ~SequenceStr();

            static TD::String_var *allocbuf( CORBA::ULong );
            static void freebuf( TD::String_var* );

            SequenceStr &operator=( const SequenceStr &s );

            CORBA::ULong maximum() const;

            void length( CORBA::ULong );
            CORBA::ULong length() const;


            TD::String_var &operator[]( CORBA::ULong index );
            const TD::String_var &operator[]( CORBA::ULong index ) const;
        private:
            CORBA::ULong _maximum;
            CORBA::ULong _length;
            TD::String_var *_buffer;
            CORBA::Boolean _release;
            TD::String_var *wkrtn;
        };

        class SequenceStr_var
        {
        public:
            SequenceStr_var();
            SequenceStr_var( SequenceStr_ptr );
            SequenceStr_var( const SequenceStr_var & );
            ~SequenceStr_var();

            SequenceStr_var &operator=( SequenceStr_ptr );
            SequenceStr_var &operator=( const SequenceStr_var & );

            operator SequenceStr_ptr() const;
            operator SequenceStr_ptr&();
            SequenceStr_ptr operator->() const;

            TD::String_var &operator[]( CORBA::ULong );
            const TD::String_var &operator[]( CORBA::ULong ) const;
            protected:
            SequenceStr *_ptr;
            TD::String_var *wkrtn;
        };
    };
    class   I3 : public virtual TD
    {
    public:
        class BSequenceStr
        {
        public:
            BSequenceStr();
            BSequenceStr( CORBA::ULong length, TD::String_var *data,
            CORBA::Boolean release = CORBA_TRUE );
            BSequenceStr( const BSequenceStr &s );
            ~BSequenceStr();

            static TD::String_var *allocbuf( CORBA::ULong );
            static void freebuf( TD::String_var* );

            BSequenceStr &operator=( const BSequenceStr &s );

            CORBA::ULong maximum() const;

            void length( CORBA::ULong );
            CORBA::ULong length() const;

            TD::String_var &operator[]( CORBA::ULong index );
            const TD::String_var &operator[]( CORBA::ULong index ) const;

        private:
            const CORBA::ULong _maximum;
            CORBA::ULong _length;
            TD::String_var *_buffer;
            CORBA::Boolean _release;
            TD::String_var *wkrtn;
        };

        class BSequenceStr_var
        {
        public:
            BSequenceStr_var();
            BSequenceStr_var( BSequenceStr_ptr );
            BSequenceStr_var( const BSequenceStr_var & );
            ~BSequenceStr_var();

            BSequenceStr_var &operator=( BSequenceStr_ptr );
            BSequenceStr_var &operator=( const BSequenceStr_var & );

            operator BSequenceStr_ptr() const;
            operator BSequenceStr_ptr&();
            BSequenceStr_ptr operator->() const;

            TD::String_var &operator[]( CORBA::ULong );
            const TD::String_var &operator[]( CORBA::ULong ) const;
            protected:
            BSequenceStr    *_ptr;
            TD::String_var *wkrtn;
        };
        ・・・
    };
    ・・・
};

(2)メンバ変数/メンバ関数
(3) シーケンス_varクラスのメンバ変数/メンバ関数
  シーケンスを宣言すると、“シーケンス名_var”クラスが生成されます。
(4)領域獲得/解放
固定長データ
可変長データ
前次
Copyright FUJITSU LIMITED 2009