6.1.2.3 シーケンス型

Interstage Application Server アプリケーション作成ガイド (コンポーネントトランザクションサービス編)

目次索引

第6章 C++言語の提供クラス

> 6.1 IDL定義を元に生成されるクラス

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

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)メンバ変数/メンバ関数

配列の最大個数(_maximum)
　
使用する配列の個数(_length)
　
配列の値(_buffer)
　
リリースフラグ(_release)
　未サポート。CORBA_TRUEだけが設定可能です。

デフォルトコンストラクタ
（M1::I1::SequenceLong::SequenceLong() ／ M1::I2::SequenceStr::SequenceStr() ／ M1::I3::BSequenceStr::BSequenceStr()）

　インスタンス生成時、シーケンス長_lengthを0で初期化します。また、サイズ指定ありのシーケンスの場合、最大長_maximumは0で初期化し、最大値が指定されたバウンディッド・シーケンスの場合、最大長_maximumは指定された最大値を設定します。

（使用例）

// 固定長データ
M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong;
              // デフォルトコンストラクタSequenceLongが呼ばれ
              // seq1が初期化されます。

// 可変長データ
M1::I2::SequenceStr *seq2 = new M1::I2::SequenceStr;
               // デフォルトコンストラクタSequenceStrが呼ばれ
               // seq2が初期化されます。

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
M1::I3::BSequenceStr *seq3 = new M1::I3::BSequenceStr;

　　　　　　　// デフォルトコンストラクタBSequenceStrが呼ばれ
　　　　　　  // seq3が初期化されます。

maximumコンストラクタ
( M1::I1::SequenceLong::SequenceLong( CORBA::ULong max) ／ M1::I2::SequenceStr::SequenceStr( CORBA::ULong max ) )

　インスタンス生成時、サイズ指定なしのシーケンスの場合、最大長_maximumを0で初期化します。

（使用例）

// 固定長データ
M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong(10);
           // maximumコンストラクタが呼ばれ
           // seq1の最大長が10に設定される

// 可変長データ
M1::I2::SequenceStr *seq2 = new M1::I2::SequenceStr(11);
           // maximumコンストラクタが呼ばれ
           // seq1の最大長が11に設定される

T *dataコンストラクタ
（ M1::I1::SequenceLong::SequenceLong( CORBA::ULong max, CORBA::ULong length, CORBA::Long *data, CORBA::Boolean release ) ／ M1::I2::SequenceStr::SequenceStr( CORBA::ULong max, CORBA::ULong length, TD::String_var *data, CORBA::Boolean release ) ／ M1::I3::BSequenceStr::BSequenceStr( CORBA::ULong length, TD::String_var *data, CORBA::Boolean release ) ）

　インスタンス生成時、サイズ指定あり/なしの両方において、パラメタで指定したシーケンス長、最大長およびバッファポインタを_length、_maximum、_bufferに設定します。ただし、最大値が指定されたバウンディッド・シーケンスの場合、_maximumは指定された最大値を設定します。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong  seq1(10,5,data,CORBA_TRUE);
　　　// T ＊dataコンストラクタが呼ばれ、
      // パラメタで指定した値で初期化される

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
　　　// T ＊dataコンストラクタが呼ばれ、
      // パラメタで指定した値で初期化される

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
　　　// T ＊dataコンストラクタが呼ばれ、
      // パラメタで指定した値で初期化される

コピーコンストラクタ
（ M1::I1::SequenceLong::SequenceLong( const SequenceLong & ) ／ M1::I2::SequenceStr::SequenceStr( const SequenceStr & ) ／ M1::I3::BSequenceStr::BSequenceStr( const BSequenceStr & ) )

　インスタンス生成時、パラメタで指定された値を_length、_maximum、_bufferに設定します。ただし、最大値が指定されたバウンディッド・シーケンスの場合、_maximumは指定された最大値を設定します。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong s1(10,5,data,CORBA_TRUE);
M1::I1::SequenceLong s2(s1);
    // コピーコンストラクタが呼ばれ、s1のデータがs2にコピーされる

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
M1::I2::SequenceStr seq2(seq1);
    // コピーコンストラクタが呼ばれ、seq1のデータがseq2にコピーされる

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
M1::I3::BSequenceStr seq2(seq1);
    // コピーコンストラクタが呼ばれ、seq1のデータがseq2にコピーされる

デストラクタ
（ M1::I1::SequenceLong::~SequenceLong() ／ M1::I2::SequenceStr_var::~SequenceStr() ／ M1::I3::BSequenceStr::~BSequenceStr()）

　インスタンス破壊時、_bufferの値に対する領域を解放します。

配列領域獲得関数
（ CORBA::Long * M1::I1::SequenceLong::allocbuf( CORBA::ULong ) ／ TD::String_var * M1::I2::SequenceStr::allocbuf( CORBA::ULong ) ／ TD::String_var * M1::I3::BSequenceStr::allocbuf( CORBA::ULong ) ）

　T *dataコンストラクタに渡すことができるシーケンスの要素の配列を割り当てます。

（使用例）

// 固定長データ
CORBA::Long *data1 = M1::I1::SequenceLong::allocbuf(5);
//data1を使用する処理
                ・
M1::I1::SequenceLong::freebuf(data1);
　　　　// 獲得した配列の領域を解放する

// 可変長データ
TD::String_var *data2 = M1::I2::SequenceStr::allocbuf(4);
//data2を使用する処理
                ・
M1::I2::SequenceStr::freebuf(data2);
　　　　// 獲得した配列の領域を解放する

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
TD::String_var *data3 = M1::I3::BSequenceStr::allocbuf(4);
      // ４つの配列領域を獲得する

配列領域解放関数
（ static void M1::I1::SequenceLong::freebuf( CORBA::Long* ) ／ static void M1::I2::SequenceStr::freebuf(TD::String_var *) ／ M1::I3::BSequenceStr::freebuf( TD::String_var * ) ）

　allocbuf関数によって割り当てられた配列を解放します。

（使用例）

// 固定長データ
CORBA::Long *data1 = M1::I1::SequenceLong::allocbuf(5);
//data1を使用する処理
                
M1::I1::SequenceLong::freebuf(data1);

　　　　// 獲得した配列の領域を解放する

// 可変長データ
TD::String_var *data2 = M1::I2::SequenceStr::allocbuf(4);
//data2を使用する処理
                
M1::I2::SequenceStr::freebuf(data2);
　　　　// 獲得した配列の領域を解放する

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
TD::String_var *data3 = M1::I3::BSequenceStr::allocbuf(4);
//data2を使用する処理
                
M1::I3::BSequenceStr::freebuf(data3);
　　　　// 獲得した配列の領域を解放する

代入演算子
（ M1::I1::SequenceLong &M1::I1::SequenceLong::operator=( const SequenceLong & ) ／ M1::I2::SequenceStr &M1::I2::SequenceStr::operator(const SequenceStr & ) ／ M1::I3::BSequenceStr &M1::I3::BSequenceStr::operator=(const BSequenceStr & ) ）

　パラメタで指定された値を_bufferに設定します。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong s1(10,5,data,CORBA_TRUE);
M1::I1::SequenceLong s2;
s2 = s1;  // 代入演算子が呼ばれ、s1のデータがs2にコピーされる

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
M1::I2::SequenceStr seq2;
seq2 = seq1;　 // 代入演算子が呼ばれ、seq1のデータがseq2にコピーされる

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
M1::I3::BSequenceStr seq2;
seq2 = seq1;　 // 代入演算子が呼ばれ、seq1のデータがseq2にコピーされる

maximum()アクセス関数（maximum獲得）
（ CORBA::ULong M1::I1::SequenceLong::maximum() const ／ CORBA::ULong M1::I2::SequenceStr::maximum() const ／ CORBA::ULongM1::I3::BSequenceStr::maximum() const）

　サイズ指定のないシーケンスの場合、現在使用可能なバッファの総数を返します。サイズが指定されたシーケンスの場合、IDLで与えられたシーケンスの大きさを返します。

（使用例）

// 固定長データ
CORBA::ULong max;
M1::I1::SequenceLong s1(5);
max = s1.maximum();  // maxの値は５

// 可変長データ
M1::I2::SequenceStr s2(4);
max = s2.maximum() ;　// maxの値は４

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
M1::I3::BSequenceStr s3;  //デフォルトコンストラクタで最大値に10が設定される
max = s3.maximum() ;　// maxの値は10

length()アクセス関数（length設定)
（ void M1::I1::SequenceLong::length( CORBA::ULong ) ／ void M1::I2::SequenceStr::length( CORBA::ULong ) ／ void M1::I3::BSequenceStr::length( CORBA::ULong ) ）

　length(Ulong)関数はパラメタで指定した値をシーケンス長に設定します。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong s1(10,5,data,CORBA_TRUE);
s1.length(5);　//シーケンス長を5に設定

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};

TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
seq1.length(4) ; //シーケンス長を4に設定

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
seq1.length(4) ; //シーケンス長を4に設定

length()アクセス関数（length獲得)
（ CORBA::ULong M1::I1::SequenceLong::length() const ／ CORBA::ULong M1::I2::SequenceStr::length() const ／ CORBA::ULong M1::I3::BSequenceStr::length() const

　シーケンス長を返します

（使用例）

// 固定長データ
CORBA::ULong len;
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong s1(10,5,data,CORBA_TRUE);
len = s1.length();　// lenの値は５

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
len = seq1.length() ;  // lenの値は４

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
len = seq1.length() ;  // lenの値は４

添字演算子
（ CORBA::Long & M1::I1::SequenceLong::operator[]( CORBA::ULong ) ／ M1::I2::SequenceStr::operator[]( CORBA::ULong ) ／ TD::String_var &M1::I3::BSequenceStr::operator[]( CORBA::ULong ) ）

　与えられたインデックスに対応する_bufferの内容を返します。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong s1(10,5,data,CORBA_TRUE);
long  l = s1[3];  // lの値は４

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
TD::String_var  d = seq1[3];   // dの値はwednesday

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
TD::String_var  d = seq1[3];   // dの値はwednesday

添字演算子（constあり）
（const CORBA::Long &M1::I1::SequenceLong::operator[]( CORBA::ULong ) const ／ const TD::String_var &M1::I2::SequenceStr::operator[](CORBA::ULong ) const ／ const TD::String_var & M1::I3::BSequenceStr::operator[]( CORBA::ULong ) const )

　与えられたインデックスに対応する_bufferの内容を返す。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong s1(10,5,data,CORBA_TRUE);
const M1::I1::SequenceLong s2(s1);
long l = s2[3];  // lの値は４

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr seq1(10,4,wkdata,CORBA_TRUE);
const M1::I2::SequenceStr seq2(seq1);

const TD::String_var d = seq2[3];  // dの値はwednesday



// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr seq1(4,wkdata,CORBA_TRUE);
const M1::I3::BSequenceStr seq2(seq1);
const TD::String_var d = seq2[3];  // dの値はwednesday

(3) シーケンス_varクラスのメンバ変数/メンバ関数

　シーケンスを宣言すると、“シーケンス名_var"クラスが生成されます。

シーケンスクラスのポインタ（*_ptr）
　
デフォルトコンストラクタ
（ M1::I1::SequenceLong_var::SequenceLong_var() ／ M1::I2::SequenceStr_var::SequenceStr_var() ／ M1::I3::BSequenceStr_var::BSequenceStr_var() ）

　インスタンス生成時、新規T*データを作成し初期化します。
```
（使用例）

// Sequence_var型のインスタンス宣言
M1::I1::SequenceLong_var seq1;
M1::I1::SequenceLong_var *seq2 = new M1::I1::SequenceLong_var;
// いずれも暗黙のうちにデフォルトコンストラクタが呼ばれる
```
T*コンストラクタ
（ M1::I1::SequenceLong_var::SequenceLong_var( SequenceLong_ptr * ) ／ M1::I2::SequenceStr_var::SequenceStr_var( SequenceStr_ptr * ) ）／ M1::I3::BSequenceStr_var::BSequenceStr_var( BSequenceStr_ptr * ) ）

　インスタンス生成時、パラメタで指定されたTポインタをメンバ変数_ptrに設定します。
```
（使用例）
M1::I1::SequenceLong_var *seq1 = new M1::I1::SequenceLong_var;
// seq1を使用した処理
・・・
M1::I1::SequenceLong_var seq2(seq1);
// T*コンストラクタ
```
コピーコンストラクタ
（ M1::I1::SequenceLong_var::SequenceLong_var( const SequenceLong_var & ) ／ M1::I2::SequenceStr_var::SequenceStr_var( const SequenceStr_var & ) ／ M1::I3::BSequenceStr_var( const BSequenceStr_var & ) ）

　インスタンス生成時、指定されたパラメタの_ptrのデータのコピーを作成し、自身の_ptrに設定します。
```
（使用例）

M1::I1::SequenceLong_var seq1;
// seq1を使用した処理
・・・
M1::I1::SequenceLong_var seq2(seq1);
// コピーコンストラクタ
```
デストラクタ
（ M1::I1::SequenceLong_var::~SequenceLong_var() ／M1::I2::SequenceStr_var::~SequenceStr_var() ／ M1::I3::BSequenceStr_var::~BSequenceStr_var()）

　インスタンス破壊時、_ptrの領域を解放します。
　
T*代入演算子
（ M1::I1::SequenceLong_var &M1::I1::SequenceLong_var::operator=( SequenceLong_ptr * ) ／ M1::I2::SequenceStr_var &M1::I2::SequenceStr_var::operator=( SequenceStr_ptr * ) ／ M1::I3::BSequenceStr_var &M1::I3::BSequenceStr_var::operator=( BSequenceStr_ptr * ) ）
```
（使用例）

M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong;
// seq1を使用した処理
・・・
M1::I1::SequenceLong_var seq2;
seq2 = seq1;
// T*代入演算子
```
代入演算子
（ M1::I1::SequenceLong_var &M1::I1::SequenceLong_var::operator=( const SequenceLong_var & ) ／ M1::I2::SequenceStr_var &M1::I2::SequenceStr_var::operator=( const SequenceStr_var & ) ／ M1::I3::BSequenceStr_var &M1::I3::BSequenceStr_var::operator=( const BSequenceStr_var & ) ）
```
（使用例）

M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong;
// seq1を使用した処理
・・・
M1::I1::SequenceLong_var seq2;
seq2 = seq1;

M1::I1::SequenceLong_var seq3 = seq2;
// 代入演算子
```
ポインタ演算子
（ M1::I1::SequenceLong *M1::I1::SequenceLong::operator->() const ／ M1::I2::SequenceStr *M1::I2::SequenceStr::operator->() const ／ M1::I3::BSequenceStr *M1::I3::BSequenceStr::operator->() const ）
```
（使用例）

M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong;

seq1->ef1 = 1;
seq1->ef2 = 2;

M1::I1::SequenceLong_var seq_2;
seq2 = seq1;
seq2->ef1 = 3;
seq2->ef2 = 4;
// ポインタ演算子
```

交換演算子
（ operator M1::I1::SequenceLong_ptr *() const ／ operator M1::I2::SequenceStr_ptr *() const ／ operator M1::I3::BSequenceStr_ptr *() const ）

（使用例）

M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong;
// seq1を使用した処理
・・・
M1::I1::SequenceLong_var seq2;
seq2 = seq1;

M1::I1::SequenceLong_var *seq3 = (M1::I1::SequenceLong*)seq2;
// 交換演算子

添字演算子 （constなし）
（ CORBA::Long &M1::I1::SequenceLong::operator[]( CORBA::ULong ) ／ TD::String_var &M1::I2::SequenceStr::operator[](CORBA::ULong ) ／ TD::String_var & M1::I3::BSequenceStr_var::operator[]( CORBA::ULong ) ）

　与えられたインデックスに対応する_bufferの内容を返します。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong (10,5,data,CORBA_TRUE);
M1::I1::SequenceLong_var vseq1;
vseq1 = seq1;
long  l = vseq1[3];  // lの値は４

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}

M1::I2::SequenceStr *seq1 = new M1::I2::SequenceStr(10,4,wkdata,CORBA_TRUE);
M1::I2::SequenceStr_var vseq1;
vseq1 = seq1;
TD::String_var  d =vseq1[3];   // dの値はwednesday

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr *seq1 = new M1::I3::BSequenceStr(4,wkdata,CORBA_TRUE);
M1::I3::BSequenceStr vseq1;
vseq1 = seq1;
TD::String_var  d = vseq1[3];   // dの値はwednesday

添字演算子（constあり）
（const CORBA::Long &M1::I1::SequenceLong::operator[]( CORBA::ULong ) const ／ const TD::String_var &M1::I2::SequenceStr::operator[](CORBA::ULong ) const ／ const TD::String_var &M1::I3::BSequenceStr_var::operator[](CORBA::ULong ) const)

　与えられたインデックスに対応する_bufferの内容を返す。

（使用例）

// 固定長データ
long data[] = {1,2,3,4,5};
M1::I1::SequenceLong *seq1 = new M1::I1::SequenceLong (10,5,data,CORBA_TRUE);
const M1::I1::SequenceLong_var vseq1(seq1);
const long  l = vseq1[3];  // lの値は４

// 可変長データ
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I2::SequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I2::SequenceStr *seq1 = new M1::I2::SequenceStr(10,4,wkdata,CORBA_TRUE);
const M1::I2::SequenceStr vseq1(seq1);
const TD::String_var  d = vseq1[3];   // dの値はwednesday

// 可変長データ（最大値が指定されたバウンディッド・シーケンス）
char *data[] = {"sunday","monday","tuesday","wednesday"};
TD::String_var *wkdata = M1::I3::BSequenceStr::allocbuf(4) ;
for (cnt = 0;cnt < 4;cnt++) {
    wkdata[cnt] = (const CORBA::Char *)data[cnt];
}
M1::I3::BSequenceStr *seq1 = new M1::I3::BSequenceStr(4,wkdata,CORBA_TRUE);

const M1::I3::BSequenceStr_var vseq1(seq1);
const TD::String_var  d = vseq1[3];   // dの値はwednesday

(4)領域獲得/解放

固定長データ

inパラメタ …領域を獲得、および解放するための特別な関数を使用する必要はありません。
outパラメタ …領域を獲得、および解放するための特別な関数を使用する必要はありません。
inoutパラメタ…領域を獲得、および解放するための特別な関数を使用する必要はありません。

可変長データ

inパラメタ …領域を獲得、および解放するための特別な関数を使用する必要はありません。
outパラメタ …シーケンスクラスのインスタンスはC++のnew演算子、シーケンスのデータ領域はallocbuf関数（XX::allocbuf()）により領域の獲得を行います。なお、ここで獲得した領域はスケルトンにより解放されます。
inoutパラメタ…領域を獲得、および解放するための特別な関数を使用する必要はありません。

目次索引