Java TCKind._tk_array方法代码示例

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
public TypeCode content_type()
    throws BadKind
{
    switch (_kind) {
    case tk_indirect:
        return indirectType().content_type();
    case TCKind._tk_sequence:
        return lazy_content_type();
    case TCKind._tk_array:
    case TCKind._tk_alias:
    case TCKind._tk_value_box:
        return _contentType;
    default:
        throw new BadKind();
    }
}
 

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
public TypeCodeImpl(ORB orb,
                    int creationKind,
                    int bound,
                    TypeCode element_type)
                    // for sequences and arrays
{
    this(orb) ;

    if ( creationKind == TCKind._tk_sequence || creationKind == TCKind._tk_array ) {
        _kind               = creationKind;
        _length             = bound;
        _contentType        = convertToNative(_orb, element_type);
    } // else initializes to null
}
 

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
public int length()
    throws BadKind
{
    switch (_kind) {
    case tk_indirect:
        return indirectType().length();
    case TCKind._tk_string:
    case TCKind._tk_wstring:
    case TCKind._tk_sequence:
    case TCKind._tk_array:
        return _length;
    default:
        throw new BadKind();
    }
}
 

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
static boolean isConstructedDynAny(DynAny dynAny) {
    // DynFixed is constructed but not a subclass of DynAnyConstructedImpl
    //return (dynAny instanceof DynAnyConstructedImpl);
    int kind = dynAny.type().kind().value();
    return (kind == TCKind._tk_sequence ||
            kind == TCKind._tk_struct ||
            kind == TCKind._tk_array ||
            kind == TCKind._tk_union ||
            kind == TCKind._tk_enum ||
            kind == TCKind._tk_fixed ||
            kind == TCKind._tk_value ||
            kind == TCKind._tk_value_box);
}
 

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
static DynAny createMostDerivedDynAny(Any any, ORB orb, boolean copyValue)
    throws org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode
{
    if (any == null || ! DynAnyUtil.isConsistentType(any.type()))
        throw new org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode();

    switch (any.type().kind().value()) {
        case TCKind._tk_sequence:
            return new DynSequenceImpl(orb, any, copyValue);
        case TCKind._tk_struct:
            return new DynStructImpl(orb, any, copyValue);
        case TCKind._tk_array:
            return new DynArrayImpl(orb, any, copyValue);
        case TCKind._tk_union:
            return new DynUnionImpl(orb, any, copyValue);
        case TCKind._tk_enum:
            return new DynEnumImpl(orb, any, copyValue);
        case TCKind._tk_fixed:
            return new DynFixedImpl(orb, any, copyValue);
        case TCKind._tk_value:
            return new DynValueImpl(orb, any, copyValue);
        case TCKind._tk_value_box:
            return new DynValueBoxImpl(orb, any, copyValue);
        default:
            return new DynAnyBasicImpl(orb, any, copyValue);
    }
}
 

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
public TypeCode create_array_tc(int length,
                                TypeCode element_type)
{
    return new TypeCodeImpl(this, TCKind._tk_array, length, element_type);
}
 

import org.omg.CORBA.TCKind; //导入方法依赖的package包/类
/**
 * Create a TypeCode for an array.
 *
 * @param length    the length of the array.
 * @param element_type
 *                  the type of elements of the array.
 * @return          the requested TypeCode.
 */
public synchronized TypeCode create_array_tc(int length,
                                TypeCode element_type)
{
    checkShutdownState();
    return new TypeCodeImpl(this, TCKind._tk_array, length, element_type);
}