示例#1
1
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__ModuleN);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "InitN", "InitN0", "()V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "__ctorModuleN0", "__ctorModuleN0", "(Lnet/sf/jni4net/inj/IClrProxy;)V"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__ProcessEvent);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKnowledgeRuntime", "getKnowledgeRuntime0", "()Lorg/drools/runtime/KnowledgeRuntime;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getProcessInstance", "getProcessInstance1", "()Lorg/drools/runtime/process/ProcessInstance;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__StatelessKnowledgeSessionResults);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getValue", "getValue0", "(Ljava/lang/String;)Ljava/lang/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getIdentifiers", "getIdentifiers1", "()Ljava/util/Collection;"));
     return methods;
 }
示例#4
1
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__Stream);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Dispose", "Dispose0", "()V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCanRead", "CanRead1", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCanSeek", "CanSeek2", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCanTimeout", "CanTimeout3", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCanWrite", "CanWrite4", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getLength", "Length5", "()J"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getPosition", "Position6", "()J"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setPosition", "Position7", "(J)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getReadTimeout", "ReadTimeout8", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setReadTimeout", "ReadTimeout9", "(I)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getWriteTimeout", "WriteTimeout10", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setWriteTimeout", "WriteTimeout11", "(I)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Close", "Close12", "()V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Flush", "Flush13", "()V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "BeginRead", "BeginRead14", "([BIILsystem/AsyncCallback;Lsystem/Object;)Lsystem/IAsyncResult;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "EndRead", "EndRead15", "(Lsystem/IAsyncResult;)I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "BeginWrite", "BeginWrite16", "([BIILsystem/AsyncCallback;Lsystem/Object;)Lsystem/IAsyncResult;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "EndWrite", "EndWrite17", "(Lsystem/IAsyncResult;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Seek", "Seek18", "(JLsystem/Enum;)J"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "SetLength", "SetLength19", "(J)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Read", "Read20", "([BII)I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "ReadByte", "ReadByte21", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Write", "Write22", "([BII)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "WriteByte", "WriteByte23", "(B)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Synchronized", "Synchronized24", "(Lsystem/io/Stream;)Lsystem/io/Stream;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__AfterRuleRemovedEvent);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKnowledgeBase", "getKnowledgeBase0", "()Lorg/drools/KnowledgeBase;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getRule", "getRule1", "()Lorg/drools/definition/rule/Rule;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__DroolsManagementAgentMBean);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKnowledgeBaseCount", "getKnowledgeBaseCount0", "()J"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getSessionCount", "getSessionCount1", "()J"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__IFormatProvider);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetFormat", "GetFormat0", "(Lsystem/Type;)Lsystem/Object;"));
     return methods;
 }
 public static object RobotArm_Proxy_RobotArmState_TO_RobotArm_RobotArmState(object transformFrom) {
     global::RobotArm.RobotArmState target = new global::RobotArm.RobotArmState();
     global::RobotArm.Proxy.RobotArmState from = ((global::RobotArm.Proxy.RobotArmState)(transformFrom));
     if ((from.Joints != null)) {
         int count = from.Joints.Count;
         global::System.Collections.Generic.List<global::Microsoft.Robotics.PhysicalModel.Proxy.Joint> tmp = new global::System.Collections.Generic.List<global::Microsoft.Robotics.PhysicalModel.Proxy.Joint>(count);
         for (int index = 0; (index < count); index = (index + 1)) {
             global::Microsoft.Robotics.PhysicalModel.Proxy.Joint tmp0 = default(global::Microsoft.Robotics.PhysicalModel.Proxy.Joint);
             if ((from.Joints[index] != null)) {
                 global::Microsoft.Robotics.PhysicalModel.Proxy.Joint tmp1 = new global::Microsoft.Robotics.PhysicalModel.Proxy.Joint();
                 ((Microsoft.Dss.Core.IDssSerializable)(from.Joints[index])).CopyTo(((Microsoft.Dss.Core.IDssSerializable)(tmp1)));
                 tmp0 = tmp1;
             }
             else {
                 tmp0 = null;
             }
             tmp.Add(tmp0);
         }
         target.Joints = tmp;
     }
     else {
         target.Joints = null;
     }
     target.EndEffectorPose = from.EndEffectorPose;
     return target;
 }
示例#9
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__Resource);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getInputStream", "getInputStream0", "()Ljava/io/InputStream;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getReader", "getReader1", "()Ljava/io/Reader;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__PropertiesConfiguration);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setProperty", "setProperty0", "(Ljava/lang/String;Ljava/lang/String;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getProperty", "getProperty1", "(Ljava/lang/String;)Ljava/lang/String;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__StatelessRuleSession);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "execute", "execute0", "(Ljava/lang/Iterable;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "execute", "execute1", "(Ljava/lang/Object;)V"));
     return methods;
 }
示例#12
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__Runnable);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "run", "run0", "()V"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__GenericDeclaration);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTypeParameters", "getTypeParameters0", "()[Ljava/lang/reflect/TypeVariable;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__GenericArrayType);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getGenericComponentType", "getGenericComponentType0", "()Ljava/lang/reflect/Type;"));
     return methods;
 }
示例#15
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__Row);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "get", "get0", "(Ljava/lang/String;)Ljava/lang/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getFactHandle", "getFactHandle1", "(Ljava/lang/String;)Lorg/drools/runtime/rule/FactHandle;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__IDebugProperty);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getValue", "getValue0", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKey", "getKey1", "()Ljava/lang/String;"));
     return methods;
 }
示例#17
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__Evaluator);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getOperator", "getOperator0", "()Lorg/drools/runtime/rule/Operator;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isTemporal", "isTemporal1", "()Z"));
     return methods;
 }
示例#18
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__FieldInfo);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getFieldType", "FieldType0", "()Lsystem/Type;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetValue", "GetValue1", "(Lsystem/Object;)Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "SetValue", "SetValue2", "(Lsystem/Object;Lsystem/Object;Lsystem/reflection/BindingFlags;Lsystem/Object;Lsy" +
                 "stem/Object;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getFieldHandle", "FieldHandle3", "()Lsystem/ValueType;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getAttributes", "Attributes4", "()Lsystem/Enum;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "SetValue", "SetValue5", "(Lsystem/Object;Lsystem/Object;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isPublic", "IsPublic6", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isPrivate", "IsPrivate7", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isFamily", "IsFamily8", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isAssembly", "IsAssembly9", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isFamilyAndAssembly", "IsFamilyAndAssembly10", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isFamilyOrAssembly", "IsFamilyOrAssembly11", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isStatic", "IsStatic12", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isInitOnly", "IsInitOnly13", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isLiteral", "IsLiteral14", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isNotSerialized", "IsNotSerialized15", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isSpecialName", "IsSpecialName16", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isPinvokeImpl", "IsPinvokeImpl17", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetFieldFromHandle", "GetFieldFromHandle18", "(Lsystem/ValueType;)Lsystem/reflection/FieldInfo;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetFieldFromHandle", "GetFieldFromHandle19", "(Lsystem/ValueType;Lsystem/ValueType;)Lsystem/reflection/FieldInfo;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetRequiredCustomModifiers", "GetRequiredCustomModifiers20", "()[Lsystem/Type;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetOptionalCustomModifiers", "GetOptionalCustomModifiers21", "()[Lsystem/Type;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetRawConstantValue", "GetRawConstantValue22", "()Lsystem/Object;"));
     return methods;
 }
示例#19
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__ParameterInfo);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetCustomAttributes", "GetCustomAttributes0", "(Z)[Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetCustomAttributes", "GetCustomAttributes1", "(Lsystem/Type;Z)[Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "IsDefined", "IsDefined2", "(Lsystem/Type;Z)Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetTypeInfoCount", "GetTypeInfoCount3", "(Lnet/sf/jni4net/Out;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetTypeInfo", "GetTypeInfo4", "(IIJ)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetIDsOfNames", "GetIDsOfNames5", "(Lnet/sf/jni4net/Ref;JIIJ)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke", "Invoke6", "(ILnet/sf/jni4net/Ref;ISJJJJ)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getParameterType", "ParameterType7", "()Lsystem/Type;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getName", "Name8", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getDefaultValue", "DefaultValue9", "()Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getRawDefaultValue", "RawDefaultValue10", "()Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getPosition", "Position11", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getAttributes", "Attributes12", "()Lsystem/Enum;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getMember", "Member13", "()Lsystem/reflection/MemberInfo;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isIn", "IsIn14", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isOut", "IsOut15", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isLcid", "IsLcid16", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isRetval", "IsRetval17", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isOptional", "IsOptional18", "()Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getMetadataToken", "MetadataToken19", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetRequiredCustomModifiers", "GetRequiredCustomModifiers20", "()[Lsystem/Type;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetOptionalCustomModifiers", "GetOptionalCustomModifiers21", "()[Lsystem/Type;"));
     return methods;
 }
示例#20
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__Operator);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getOperatorString", "getOperatorString0", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "isNegated", "isNegated1", "()Z"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__EventListener);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "signalEvent", "signalEvent0", "(Ljava/lang/String;Ljava/lang/Object;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getEventTypes", "getEventTypes1", "()[Ljava/lang/String;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__IFormattable);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "ToString", "ToString0", "(Ljava/lang/String;Lsystem/IFormatProvider;)Ljava/lang/String;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__NodeInstanceContainer);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getNodeInstances", "getNodeInstances0", "()Ljava/util/Collection;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getNodeInstance", "getNodeInstance1", "(J)Lorg/drools/runtime/process/NodeInstance;"));
     return methods;
 }
示例#24
0
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__Exception);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getMessage", "Message0", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getData", "Data1", "()Lsystem/collections/IDictionary;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetBaseException", "GetBaseException2", "()Lsystem/Exception;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getInnerException", "InnerException3", "()Lsystem/Exception;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTargetSite", "TargetSite4", "()Lsystem/reflection/MethodBase;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getStackTraceNet", "StackTrace5", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getHelpLink", "HelpLink6", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setHelpLink", "HelpLink7", "(Ljava/lang/String;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getSource", "Source8", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setSource", "Source9", "(Ljava/lang/String;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "ToString", "ToString10", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetObjectData", "GetObjectData11", "(Lsystem/runtime/serialization/SerializationInfo;Lsystem/runtime/serialization/St" +
                 "reamingContext;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetType", "GetType12", "()Lsystem/Type;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Equals", "Equals13", "(Lsystem/Object;)Z"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "GetHashCode", "GetHashCode14", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "__ctorException0", "__ctorException0", "(Lnet/sf/jni4net/inj/IClrProxy;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "__ctorException1", "__ctorException1", "(Lnet/sf/jni4net/inj/IClrProxy;Ljava/lang/String;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "__ctorException2", "__ctorException2", "(Lnet/sf/jni4net/inj/IClrProxy;Ljava/lang/String;Lsystem/Exception;)V"));
     return methods;
 }
 public static object PololuMaestro_Proxy_PololuMaestroState_TO_PololuMaestro_PololuMaestroState(object transformFrom) {
     global::PololuMaestro.PololuMaestroState target = new global::PololuMaestro.PololuMaestroState();
     global::PololuMaestro.Proxy.PololuMaestroState from = ((global::PololuMaestro.Proxy.PololuMaestroState)(transformFrom));
     if ((from.Channels != null)) {
         int count = from.Channels.Count;
         global::System.Collections.Generic.List<global::PololuMaestro.ChannelInfo> tmp = new global::System.Collections.Generic.List<global::PololuMaestro.ChannelInfo>(count);
         for (int index = 0; (index < count); index = (index + 1)) {
             global::PololuMaestro.ChannelInfo tmp0 = default(global::PololuMaestro.ChannelInfo);
             if ((from.Channels[index] != null)) {
                 tmp0 = ((global::PololuMaestro.ChannelInfo)(PololuMaestro_Proxy_ChannelInfo_TO_PololuMaestro_ChannelInfo(from.Channels[index])));
             }
             else {
                 tmp0 = null;
             }
             tmp.Add(tmp0);
         }
         target.Channels = tmp;
     }
     else {
         target.Channels = null;
     }
     target.SerialNumber = from.SerialNumber;
     target.Connected = from.Connected;
     target.PollingInterval = from.PollingInterval;
     return target;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__ConsequenceExceptionHandler);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "handleException", "handleException0", "(Lorg/drools/runtime/rule/Activation;Lorg/drools/runtime/rule/WorkingMemory;Ljava" +
                 "/lang/Exception;)V"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__IEvidenceFactory);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getEvidence", "Evidence0", "()Lsystem/Object;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__SystemEventListenerService);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setSystemEventListener", "setSystemEventListener0", "(Lorg/drools/SystemEventListener;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getSystemEventListener", "getSystemEventListener1", "()Lorg/drools/SystemEventListener;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__RuleFlowGroup);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "clear", "clear0", "()V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getName", "getName1", "()Ljava/lang/String;"));
     return methods;
 }
 private static global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class) {
     global::System.Type @__type = typeof(__KnowledgeBuilderError);
     global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List<global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getMessage", "getMessage0", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getErrorLines", "getErrorLines1", "()[I"));
     return methods;
 }
示例#31
0
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__BatchExecutionCommand);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     return(methods);
 }
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__IBattleListener);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattleStarted", "onBattleStarted0", "(Lrobocode/control/events/BattleStartedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattleFinished", "onBattleFinished1", "(Lrobocode/control/events/BattleFinishedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattleCompleted", "onBattleCompleted2", "(Lrobocode/control/events/BattleCompletedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattlePaused", "onBattlePaused3", "(Lrobocode/control/events/BattlePausedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattleResumed", "onBattleResumed4", "(Lrobocode/control/events/BattleResumedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onRoundStarted", "onRoundStarted5", "(Lrobocode/control/events/RoundStartedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onRoundEnded", "onRoundEnded6", "(Lrobocode/control/events/RoundEndedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onTurnStarted", "onTurnStarted7", "(Lrobocode/control/events/TurnStartedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onTurnEnded", "onTurnEnded8", "(Lrobocode/control/events/TurnEndedEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattleMessage", "onBattleMessage9", "(Lrobocode/control/events/BattleMessageEvent;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "onBattleError", "onBattleError10", "(Lrobocode/control/events/BattleErrorEvent;)V"));
     return(methods);
 }
示例#33
0
    public async partial global::System.Threading.Tasks.Task <global::System.Collections.Generic.List <global::SomeType> > TaskAsync(global::System.Data.Common.DbConnection connection, int id, string name)
    {
        // locals
        global::System.Data.Common.DbCommand?   __dapper__command = null;
        global::System.Data.Common.DbDataReader?__dapper__reader  = null;
        bool __dapper__close = false;

        int[]? __dapper__tokenBuffer = null;
        global::System.Collections.Generic.List <global::SomeType> __dapper__result;
        try
        {
            // prepare connection
            if (connection !.State == global::System.Data.ConnectionState.Closed)
            {
                await connection !.OpenAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false);
                __dapper__close = true;
            }

            // prepare command (excluding parameter values)
            if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_Multiple_input_cs_TaskAsync_10, null)) is null)
            {
                __dapper__command = __dapper__CreateCommand(connection !);
            }
            else
            {
                __dapper__command.Connection = connection;
            }

            // assign parameter values
#pragma warning disable CS0618
            __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id);
            __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(name);
#pragma warning restore CS0618

            // execute reader
            const global::System.Data.CommandBehavior __dapper__behavior = global::System.Data.CommandBehavior.SequentialAccess | global::System.Data.CommandBehavior.SingleResult | global::System.Data.CommandBehavior.SingleRow;
            __dapper__reader = await __dapper__command.ExecuteReaderAsync(__dapper__close?(__dapper__behavior | global::System.Data.CommandBehavior.CloseConnection) : __dapper__behavior, global::System.Threading.CancellationToken.None).ConfigureAwait(false);

            __dapper__close = false;             // performed via CommandBehavior

            // process multiple rows
            __dapper__result = new global::System.Collections.Generic.List <global::SomeType>();
            if (__dapper__reader.HasRows)
            {
                var __dapper__parser = global::Dapper.TypeReader.TryGetReader <global::SomeType>() !;
                var __dapper__tokens = global::Dapper.TypeReader.RentSegment(ref __dapper__tokenBuffer, __dapper__reader.FieldCount);
                __dapper__parser.IdentifyFieldTokensFromSchema(__dapper__reader, __dapper__tokens);
                while (await __dapper__reader.ReadAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false))
                {
                    __dapper__result.Add(await __dapper__parser.ReadAsync(__dapper__reader, __dapper__tokens, global::System.Threading.CancellationToken.None).ConfigureAwait(false));
                }
            }
            // consume additional results (ensures errors from the server are observed)
            while (await __dapper__reader.NextResultAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false))
            {
            }

            // TODO: post-process parameters

            // return rowset
            return(__dapper__result);
        }
        finally
        {
            // cleanup
            global::Dapper.TypeReader.Return(ref __dapper__tokenBuffer);
            __dapper__reader?.Dispose();
            if (__dapper__command is not null)
            {
                __dapper__command.Connection = default;
                __dapper__command            = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_Multiple_input_cs_TaskAsync_10, __dapper__command);
                __dapper__command?.Dispose();
            }
            if (__dapper__close)
            {
                connection?.Close();
            }
        }
 public static void CreateListadoGenerico_1 <T>(global::Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder __builder, int seq, int __seq0, global::System.Collections.Generic.List <T> __arg0, int __seq1, global::Microsoft.AspNetCore.Components.RenderFragment __arg1)
 {
     __builder.OpenComponent <global::SurcosBlazor.Client.Shared.ListadoGenerico <T> >(seq);
     __builder.AddAttribute(__seq0, "listado", __arg0);
     __builder.AddAttribute(__seq1, "HayRegistros", __arg1);
     __builder.CloseComponent();
 }
 public ObstacleSTData()
 {
     polygon      = new global::System.Collections.Generic.List <ObstacleSTRawData.STPointPair>();
     distribution = new global::System.Collections.Generic.List <ObstacleSTRawData.STPointPair>();
     OnConstructor();
 }
示例#36
0
 public Extrinsics()
 {
     tansforms = new global::System.Collections.Generic.List <Transform>();
     OnConstructor();
 }
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__BeforeKnowledgePackageAddedEvent);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKnowledgeBase", "getKnowledgeBase0", "()Lorg/drools/KnowledgeBase;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKnowledgePackage", "getKnowledgePackage1", "()Lorg/drools/definition/KnowledgePackage;"));
     return(methods);
 }
 public SceneManagerConfig()
 {
     service_name = new global::System.Collections.Generic.List <string>();
     OnConstructor();
 }
示例#39
0
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__SessionClock);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentTime", "getCurrentTime0", "()J"));
     return(methods);
 }
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__ISerializableHelper);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "serialize", "serialize0", "(Lnet/sf/robocode/serialization/RbSerializer;Ljava/nio/ByteBuffer;Ljava/lang/Obje" +
                                                                   "ct;)V"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "deserialize", "deserialize1", "(Lnet/sf/robocode/serialization/RbSerializer;Ljava/nio/ByteBuffer;)Ljava/lang/Obj" +
                                                                   "ect;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "sizeOf", "sizeOf2", "(Lnet/sf/robocode/serialization/RbSerializer;Ljava/lang/Object;)I"));
     return(methods);
 }
示例#41
0
 /// <summary>
 /// Return a list of all resources in this folder and all sub-folders.
 /// The result of this method is cached, so subsequent calls will have very low performance cost.
 /// </summary>
 /// <returns>A list of resource objects in this folder and sub-folders.</returns>
 public static global::System.Collections.Generic.IList <global::TypeSafe.IResource> GetContentsRecursive()
 {
     if ((__ts_internal_recursiveLookupCache != null))
     {
         return(__ts_internal_recursiveLookupCache);
     }
     global::System.Collections.Generic.List <global::TypeSafe.IResource> tmp = new global::System.Collections.Generic.List <global::TypeSafe.IResource>();
     tmp.AddRange(GetContents());
     tmp.AddRange(Options.GetContentsRecursive());
     tmp.AddRange(Tabs.GetContentsRecursive());
     __ts_internal_recursiveLookupCache = tmp;
     return(__ts_internal_recursiveLookupCache);
 }
示例#42
0
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__ConstructorInfo);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke_2", "Invoke_20", "(Lsystem/Object;Lsystem/reflection/BindingFlags;Lsystem/Object;[Lsystem/Object;Ls" +
                                                                   "ystem/Object;)Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke_3", "Invoke_31", "(Lsystem/Object;[Lsystem/Object;)Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke_4", "Invoke_42", "(Lsystem/reflection/BindingFlags;Lsystem/Object;[Lsystem/Object;Lsystem/Object;)L" +
                                                                   "system/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke_5", "Invoke_53", "([Lsystem/Object;)Lsystem/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke", "Invoke4", "(Lsystem/reflection/BindingFlags;Lsystem/Object;[Lsystem/Object;Lsystem/Object;)L" +
                                                                   "system/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "Invoke", "Invoke5", "([Lsystem/Object;)Lsystem/Object;"));
     return(methods);
 }
示例#43
0
 public static global::System.Collections.ObjectModel.ReadOnlyCollection <global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets> GetLinks(global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElement source, global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElement target)
 {
     global::System.Collections.Generic.List <global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets>  outLinks = new global::System.Collections.Generic.List <global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets>();
     global::System.Collections.Generic.IList <global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets> links    = DslModeling::DomainRoleInfo.GetElementLinks <global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets>(source, global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets.SourceDomainRoleId);
     foreach (global::UPM_IPS.DCMLRACPGProyectoIPS.ExampleElementReferencesTargets link in links)
     {
         if (target.Equals(link.Target))
         {
             outLinks.Add(link);
         }
     }
     return(outLinks.AsReadOnly());
 }
 public SecondEventPayload(float field1, global::System.Collections.Generic.List <double> field2)
 {
     Field1 = field1;
     Field2 = field2;
 }
 public static global::System.Collections.ObjectModel.ReadOnlyCollection <global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder> GetLinks(global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplay source, global::Microsoft.VisualStudio.Modeling.Diagrams.Diagram target)
 {
     global::System.Collections.Generic.List <global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder>  outLinks = new global::System.Collections.Generic.List <global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder>();
     global::System.Collections.Generic.IList <global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder> links    = DslModeling::DomainRoleInfo.GetElementLinks <global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder>(source, global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder.DiagramDisplayDomainRoleId);
     foreach (global::ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplayHasDiagramOrder link in links)
     {
         if (target.Equals(link.Diagram))
         {
             outLinks.Add(link);
         }
     }
     return(outLinks.AsReadOnly());
 }
示例#46
0
 public FnnVehicleModel()
 {
     layer = new global::System.Collections.Generic.List <Layer>();
     OnConstructor();
 }
    public static void Main()
    {
        // Setup collection
        DoubleVector vect = new DoubleVector();

        for (int i = 0; i < collectionSize; i++)
        {
            double num = i * 10.1;
            vect.Add(num);
        }

        // Count property test
        if (vect.Count != collectionSize)
        {
            throw new Exception("Count test failed");
        }

        // IsFixedSize property test
        if (vect.IsFixedSize)
        {
            throw new Exception("IsFixedSize test failed");
        }

        // IsReadOnly property test
        if (vect.IsReadOnly)
        {
            throw new Exception("IsReadOnly test failed");
        }

        // Item indexing
        vect[0] = 200.1;
        if (vect[0] != 200.1)
        {
            throw new Exception("Item property test failed");
        }
        vect[0] = 0 * 10.1;
        try {
            vect[-1] = 777.1;
            throw new Exception("Item out of range (1) test failed");
        } catch (ArgumentOutOfRangeException) {
        }
        try {
            vect[vect.Count] = 777.1;
            throw new Exception("Item out of range (2) test failed");
        } catch (ArgumentOutOfRangeException) {
        }

        // CopyTo() test
        {
            double[] outputarray = new double[collectionSize];
            vect.CopyTo(outputarray);
            int index = 0;
            foreach (double val in outputarray)
            {
                if (vect[index] != val)
                {
                    throw new Exception("CopyTo (1) test failed, index:" + index);
                }
                index++;
            }
        }
        {
            double[] outputarray = new double[midCollection + collectionSize];
            vect.CopyTo(outputarray, midCollection);
            int index = midCollection;
            foreach (double val in vect)
            {
                if (outputarray[index] != val)
                {
                    throw new Exception("CopyTo (2) test failed, index:" + index);
                }
                index++;
            }
        }
        {
            double[] outputarray = new double[3];
            vect.CopyTo(10, outputarray, 1, 2);
            if (outputarray[0] != 0.0 || outputarray[1] != vect[10] || outputarray[2] != vect[11])
            {
                throw new Exception("CopyTo (3) test failed");
            }
        }
        {
            double[] outputarray = new double[collectionSize - 1];
            try {
                vect.CopyTo(outputarray);
                throw new Exception("CopyTo (4) test failed");
            } catch (ArgumentException) {
            }
        }
        {
            StructVector inputvector = new StructVector();
            int          arrayLen    = 10;
            for (int i = 0; i < arrayLen; i++)
            {
                inputvector.Add(new Struct(i / 10.0));
            }
            Struct[] outputarray = new Struct[arrayLen];
            inputvector.CopyTo(outputarray);
            for (int i = 0; i < arrayLen; i++)
            {
                if (outputarray[i].num != inputvector[i].num)
                {
                    throw new Exception("CopyTo (6) test failed, i:" + i);
                }
            }
            foreach (Struct s in inputvector)
            {
                s.num += 20.0;
            }
            for (int i = 0; i < arrayLen; i++)
            {
                if (outputarray[i].num + 20.0 != inputvector[i].num)
                {
                    throw new Exception("CopyTo (7) test failed (only a shallow copy was made), i:" + i);
                }
            }
        }
        {
            try {
                vect.CopyTo(null);
                throw new Exception("CopyTo (8) test failed");
            } catch (ArgumentNullException) {
            }
        }

        // Contains() test
        if (!vect.Contains(0 * 10.1))
        {
            throw new Exception("Contains test 1 failed");
        }
        if (!vect.Contains(10 * 10.1))
        {
            throw new Exception("Contains test 2 failed");
        }
        if (!vect.Contains(19 * 10.1))
        {
            throw new Exception("Contains test 3 failed");
        }
        if (vect.Contains(20 * 10.1))
        {
            throw new Exception("Contains test 4 failed");
        }

        {
            // IEnumerable constructor
            double[]     doubleArray = new double[] { 0.0, 11.1, 22.2, 33.3, 44.4, 55.5, 33.3 };
            DoubleVector dv          = new DoubleVector(doubleArray);
            if (doubleArray.Length != dv.Count)
            {
                throw new Exception("ICollection constructor length check failed: " + doubleArray.Length + "-" + dv.Count);
            }
            for (int i = 0; i < doubleArray.Length; i++)
            {
                if (doubleArray[i] != dv[i])
                {
                    throw new Exception("ICollection constructor failed, index:" + i);
                }
            }
            {
                Struct[]     structArray = new Struct[] { new Struct(0.0), new Struct(11.1), new Struct(22.2), new Struct(33.3) };
                StructVector sv          = new StructVector(structArray);
                for (int i = 0; i < structArray.Length; i++)
                {
                    structArray[i].num += 200.0;
                }
                for (int i = 0; i < structArray.Length; i++)
                {
                    if (structArray[i].num != sv[i].num + 200.0)
                    {
                        throw new Exception("ICollection constructor not a deep copy, index:" + i);
                    }
                }
            }
            try {
                new DoubleVector((System.Collections.ICollection)null);
                throw new Exception("ICollection constructor null test failed");
            } catch (ArgumentNullException) {
            }
            {
                // Collection initializer test, requires C# 3.0
//        myDoubleVector = new DoubleVector() { 123.4, 567.8, 901.2 };
            }

            // IndexOf() test
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect.IndexOf(i * 10.1) != i)
                {
                    throw new Exception("IndexOf test " + i + " failed");
                }
            }
            if (vect.IndexOf(200.1) != -1)
            {
                throw new Exception("IndexOf non-existent test failed");
            }
            if (dv.IndexOf(33.3) != 3)
            {
                throw new Exception("IndexOf position test failed");
            }

            // LastIndexOf() test
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect.LastIndexOf(i * 10.1) != i)
                {
                    throw new Exception("LastIndexOf test " + i + " failed");
                }
            }
            if (vect.LastIndexOf(200.1) != -1)
            {
                throw new Exception("LastIndexOf non-existent test failed");
            }
            if (dv.LastIndexOf(33.3) != 6)
            {
                throw new Exception("LastIndexOf position test failed");
            }

            // Copy constructor test
            DoubleVector dvCopy = new DoubleVector(dv);
            for (int i = 0; i < doubleArray.Length; i++)
            {
                if (doubleArray[i] != dvCopy[i])
                {
                    throw new Exception("Copy constructor failed, index:" + i);
                }
            }
            if (dvCopy.Count != doubleArray.Length)
            {
                throw new Exception("Copy constructor lengths mismatch");
            }

            // ToArray test
            double[] dvArray = dv.ToArray();
            for (int i = 0; i < doubleArray.Length; i++)
            {
                if (doubleArray[i] != dvArray[i])
                {
                    throw new Exception("ToArray failed, index:" + i);
                }
            }
            if (dvArray.Length != doubleArray.Length)
            {
                throw new Exception("ToArray lengths mismatch");
            }
        }
        {
            // Repeat() test
            try {
                myDoubleVector = DoubleVector.Repeat(77.7, -1);
                throw new Exception("Repeat negative count test failed");
            } catch (ArgumentOutOfRangeException) {
            }
            DoubleVector dv = DoubleVector.Repeat(77.7, 5);
            if (dv.Count != 5)
            {
                throw new Exception("Repeat count test failed");
            }

            // Also tests enumerator
            {
                System.Collections.IEnumerator myEnumerator = dv.GetEnumerator();
                while (myEnumerator.MoveNext())
                {
                    if ((double)myEnumerator.Current != 77.7)
                    {
                        throw new Exception("Repeat (1) test failed");
                    }
                }
            }
            {
                System.Collections.Generic.IEnumerator <double> myEnumerator = dv.GetEnumerator();
                while (myEnumerator.MoveNext())
                {
                    if (myEnumerator.Current != 77.7)
                    {
                        throw new Exception("Repeat (2) test failed");
                    }
                }
            }
        }

        {
            // InsertRange() test
            DoubleVector dvect = new DoubleVector();
            for (int i = 0; i < 5; i++)
            {
                dvect.Add(1000.0 * i);
            }
            vect.InsertRange(midCollection, dvect);
            if (vect.Count != collectionSize + dvect.Count)
            {
                throw new Exception("InsertRange test size failed");
            }

            for (int i = 0; i < midCollection; i++)
            {
                if (vect.IndexOf(i * 10.1) != i)
                {
                    throw new Exception("InsertRange (1) test " + i + " failed");
                }
            }
            for (int i = 0; i < dvect.Count; i++)
            {
                if (vect[i + midCollection] != dvect[i])
                {
                    throw new Exception("InsertRange (2) test " + i + " failed");
                }
            }
            for (int i = midCollection; i < collectionSize; i++)
            {
                if (vect.IndexOf(i * 10.1) != i + dvect.Count)
                {
                    throw new Exception("InsertRange (3) test " + i + " failed");
                }
            }
            try {
                vect.InsertRange(0, null);
                throw new Exception("InsertRange (4) test failed");
            } catch (ArgumentNullException) {
            }

            // RemoveRange() test
            vect.RemoveRange(0, 0);
            vect.RemoveRange(midCollection, dvect.Count);
            if (vect.Count != collectionSize)
            {
                throw new Exception("RemoveRange test size failed");
            }
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect.IndexOf(i * 10.1) != i)
                {
                    throw new Exception("RemoveRange test " + i + " failed");
                }
            }
            try {
                vect.RemoveRange(-1, 0);
                throw new Exception("RemoveRange index out of range (1) test failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                vect.RemoveRange(0, -1);
                throw new Exception("RemoveRange count out of range (2) test failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                vect.RemoveRange(collectionSize + 1, 0);
                throw new Exception("RemoveRange index and count out of range (1) test failed");
            } catch (ArgumentException) {
            }
            try {
                vect.RemoveRange(0, collectionSize + 1);
                throw new Exception("RemoveRange index and count out of range (2) test failed");
            } catch (ArgumentException) {
            }

            // AddRange() test
            vect.AddRange(dvect);
            if (vect.Count != collectionSize + dvect.Count)
            {
                throw new Exception("AddRange test size failed");
            }
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect.IndexOf(i * 10.1) != i)
                {
                    throw new Exception("AddRange (1) test " + i + " failed");
                }
            }
            for (int i = 0; i < dvect.Count; i++)
            {
                if (vect[i + collectionSize] != dvect[i])
                {
                    throw new Exception("AddRange (2) test " + i + " failed");
                }
            }
            try {
                vect.AddRange(null);
                throw new Exception("AddRange (3) test failed");
            } catch (ArgumentNullException) {
            }
            vect.RemoveRange(collectionSize, dvect.Count);

            // GetRange() test
            int          rangeSize   = 5;
            DoubleVector returnedVec = vect.GetRange(0, 0);
            returnedVec = vect.GetRange(midCollection, rangeSize);
            if (returnedVec.Count != rangeSize)
            {
                throw new Exception("GetRange test size failed");
            }
            for (int i = 0; i < rangeSize; i++)
            {
                if (returnedVec.IndexOf((i + midCollection) * 10.1) != i)
                {
                    throw new Exception("GetRange test " + i + " failed");
                }
            }
            try {
                vect.GetRange(-1, 0);
                throw new Exception("GetRange index out of range (1) test failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                vect.GetRange(0, -1);
                throw new Exception("GetRange count out of range (2) test failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                vect.GetRange(collectionSize + 1, 0);
                throw new Exception("GetRange index and count out of range (1) test failed");
            } catch (ArgumentException) {
            }
            try {
                vect.GetRange(0, collectionSize + 1);
                throw new Exception("GetRange index and count out of range (2) test failed");
            } catch (ArgumentException) {
            }
            {
                StructVector inputvector = new StructVector();
                int          arrayLen    = 10;
                for (int i = 0; i < arrayLen; i++)
                {
                    inputvector.Add(new Struct(i / 10.0));
                }
                StructVector outputvector = inputvector.GetRange(0, arrayLen);
                for (int i = 0; i < arrayLen; i++)
                {
                    if (outputvector[i].num != inputvector[i].num)
                    {
                        throw new Exception("GetRange (1) test failed, i:" + i);
                    }
                }
                foreach (Struct s in inputvector)
                {
                    s.num += 20.0;
                }
                for (int i = 0; i < arrayLen; i++)
                {
                    if (outputvector[i].num + 20.0 != inputvector[i].num)
                    {
                        throw new Exception("GetRange (2) test failed (only a shallow copy was made), i:" + i);
                    }
                }
            }
        }

        // Insert() test
        int pos   = 0;
        int count = vect.Count;

        vect.Insert(pos, -5.1);
        count++;
        if (vect.Count != count || vect[pos] != -5.1)
        {
            throw new Exception("Insert at beginning test failed");
        }

        pos = midCollection;
        vect.Insert(pos, 85.1);
        count++;
        if (vect.Count != count || vect[pos] != 85.1)
        {
            throw new Exception("Insert at " + pos + " test failed");
        }

        pos = vect.Count;
        vect.Insert(pos, 195.1);
        count++;
        if (vect.Count != count || vect[pos] != 195.1)
        {
            throw new Exception("Insert at end test failed");
        }

        pos = vect.Count + 1;
        try {
            vect.Insert(pos, 222.1); // should throw
            throw new Exception("Insert after end (1) test failed");
        } catch (ArgumentOutOfRangeException) {
        }
        if (vect.Count != count)
        {
            throw new Exception("Insert after end (2) test failed");
        }

        pos = -1;
        try {
            vect.Insert(pos, 333.1); // should throw
            throw new Exception("Insert before start (1) test failed");
        } catch (ArgumentOutOfRangeException) {
        }
        if (vect.Count != count)
        {
            throw new Exception("Insert before start (2) test failed");
        }

        // Remove() test
        vect.Remove(195.1);
        count--;
        vect.Remove(-5.1);
        count--;
        vect.Remove(85.1);
        count--;
        vect.Remove(9999.1); // element does not exist, should quietly do nothing
        if (vect.Count != count)
        {
            throw new Exception("Remove count check test failed");
        }
        for (int i = 0; i < collectionSize; i++)
        {
            if (vect[i] != i * 10.1)
            {
                throw new Exception("Remove test failed, index:" + i);
            }
        }

        // RemoveAt() test
        vect.Insert(0, -4.1);
        vect.Insert(midCollection, 84.1);
        vect.Insert(vect.Count, 194.1);
        vect.RemoveAt(vect.Count - 1);
        vect.RemoveAt(midCollection);
        vect.RemoveAt(0);
        try {
            vect.RemoveAt(-1);
            throw new Exception("RemoveAt test (1) failed");
        } catch (ArgumentOutOfRangeException) {
        }
        try {
            vect.RemoveAt(vect.Count);
            throw new Exception("RemoveAt test (2) failed");
        } catch (ArgumentOutOfRangeException) {
        }
        for (int i = 0; i < collectionSize; i++)
        {
            if (vect[i] != i * 10.1)
            {
                throw new Exception("RemoveAt test (3) failed, index:" + i);
            }
        }

        {
            // Capacity test
            try {
                myDoubleVector = new DoubleVector(-1);
                throw new Exception("constructor setting capacity (1) test failed");
            } catch (ArgumentOutOfRangeException) {
            }

            DoubleVector dv = new DoubleVector(10);
            if (dv.Capacity != 10 || dv.Count != 0)
            {
                throw new Exception("constructor setting capacity (2) test failed");
            }
            dv.Capacity = 20;
            if (dv.Capacity != 20)
            {
                throw new Exception("capacity test (1) failed");
            }
            dv.Add(1.11);
            try {
                dv.Capacity = dv.Count - 1;
                throw new Exception("capacity test (2) failed");
            } catch (ArgumentOutOfRangeException) {
            }

            // SetRange() test
            for (int i = dv.Count; i < collectionSize; i++)
            {
                dv.Add(0.0);
            }
            dv.SetRange(0, vect);
            if (dv.Count != collectionSize)
            {
                throw new Exception("SetRange count check test failed");
            }
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect[i] != dv[i])
                {
                    throw new Exception("SetRange test (1) failed, index:" + i);
                }
            }
            try {
                dv.SetRange(-1, vect);
                throw new Exception("SetRange test (2) failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                dv.SetRange(1, vect);
                throw new Exception("SetRange test (3) failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                vect.SetRange(0, null);
                throw new Exception("SetRange (4) test failed");
            } catch (ArgumentNullException) {
            }

            // Reverse() test
            dv.Reverse();
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect[i] != dv[collectionSize - i - 1])
                {
                    throw new Exception("Reverse test (1) failed, index:" + i);
                }
            }
            dv.Reverse(0, collectionSize);
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect[i] != dv[i])
                {
                    throw new Exception("Reverse test (2) failed, index:" + i);
                }
            }
            dv.Reverse(0, 0); // should do nothing!
            for (int i = 0; i < collectionSize; i++)
            {
                if (vect[i] != dv[i])
                {
                    throw new Exception("Reverse test (3) failed, index:" + i);
                }
            }
            try {
                dv.Reverse(-1, 0);
                throw new Exception("Reverse test (4) failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                dv.Reverse(0, -1);
                throw new Exception("Reverse test (5) failed");
            } catch (ArgumentOutOfRangeException) {
            }
            try {
                dv.Reverse(collectionSize + 1, 0);
                throw new Exception("Reverse test (6) failed");
            } catch (ArgumentException) {
            }
            try {
                dv.Reverse(0, collectionSize + 1);
                throw new Exception("Reverse test (7) failed");
            } catch (ArgumentException) {
            }
        }

        // foreach test
        {
            int index = 0;
            foreach (double s in vect)
            {
                if (s != index * 10.1)
                {
                    throw new Exception("foreach test failed, index:" + index);
                }
                index++;
            }
        }

        // Clear() test
        vect.Clear();
        if (vect.Count != 0)
        {
            throw new Exception("Clear failed");
        }

        // Finally test the methods being wrapped
        {
            IntVector iv = new IntVector();
            for (int i = 0; i < 4; i++)
            {
                iv.Add(i);
            }

            double x = li_std_vector.average(iv);
            x           += li_std_vector.average(new IntVector(new int[] { 1, 2, 3, 4 }));
            myRealVector = li_std_vector.half(new RealVector(new float[] { 10F, 10.5F, 11F, 11.5F }));

            DoubleVector dvec = new DoubleVector();
            for (int i = 0; i < 10; i++)
            {
                dvec.Add(i / 2.0);
            }
            li_std_vector.halve_in_place(dvec);
        }

        // Dispose()
        {
            using (StructVector vs = new StructVector(new Struct[] { new Struct(0.0), new Struct(11.1) }))
                using (DoubleVector vd = new DoubleVector(new double[] { 0.0, 11.1 })) {
                }
        }

        // More wrapped methods
        {
            RealVector v0  = li_std_vector.vecreal(new RealVector());
            float      flo = 123.456f;
            v0.Add(flo);
            flo = v0[0];

            IntVector         v1 = li_std_vector.vecintptr(new IntVector());
            IntPtrVector      v2 = li_std_vector.vecintptr(new IntPtrVector());
            IntConstPtrVector v3 = li_std_vector.vecintconstptr(new IntConstPtrVector());

            v1.Add(123);
            v2.Clear();
            v3.Clear();

            StructVector         v4 = li_std_vector.vecstruct(new StructVector());
            StructPtrVector      v5 = li_std_vector.vecstructptr(new StructPtrVector());
            StructConstPtrVector v6 = li_std_vector.vecstructconstptr(new StructConstPtrVector());

            v4.Add(new Struct(123));
            v5.Add(new Struct(123));
            v6.Add(new Struct(123));
        }

        // Test vectors of pointers
        {
            StructPtrVector inputvector = new StructPtrVector();
            int             arrayLen    = 10;
            for (int i = 0; i < arrayLen; i++)
            {
                inputvector.Add(new Struct(i / 10.0));
            }
            Struct[] outputarray = new Struct[arrayLen];
            inputvector.CopyTo(outputarray);
            for (int i = 0; i < arrayLen; i++)
            {
                if (outputarray[i].num != inputvector[i].num)
                {
                    throw new Exception("StructPtrVector test (1) failed, i:" + i);
                }
            }
            foreach (Struct s in inputvector)
            {
                s.num += 20.0;
            }
            for (int i = 0; i < arrayLen; i++)
            {
                if (outputarray[i].num != 20.0 + i / 10.0)
                {
                    throw new Exception("StructPtrVector test (2) failed (a deep copy was incorrectly made), i:" + i);
                }
            }

            int             rangeSize   = 5;
            int             mid         = arrayLen / 2;
            StructPtrVector returnedVec = inputvector.GetRange(mid, rangeSize);
            for (int i = 0; i < rangeSize; i++)
            {
                if (inputvector[i + mid].num != returnedVec[i].num)
                {
                    throw new Exception("StructPtrVector test (3) failed, i:" + i);
                }
            }
        }

        // Test vectors of const pointers
        {
            StructConstPtrVector inputvector = new StructConstPtrVector();
            int arrayLen = 10;
            for (int i = 0; i < arrayLen; i++)
            {
                inputvector.Add(new Struct(i / 10.0));
            }
            Struct[] outputarray = new Struct[arrayLen];
            inputvector.CopyTo(outputarray);
            for (int i = 0; i < arrayLen; i++)
            {
                if (outputarray[i].num != inputvector[i].num)
                {
                    throw new Exception("StructConstPtrVector test (1) failed, i:" + i);
                }
            }
            foreach (Struct s in inputvector)
            {
                s.num += 20.0;
            }
            for (int i = 0; i < arrayLen; i++)
            {
                if (outputarray[i].num != 20.0 + i / 10.0)
                {
                    throw new Exception("StructConstPtrVector test (2) failed (a deep copy was incorrectly made), i:" + i);
                }
            }

            int rangeSize = 5;
            int mid       = arrayLen / 2;
            StructConstPtrVector returnedVec = inputvector.GetRange(mid, rangeSize);
            for (int i = 0; i < rangeSize; i++)
            {
                if (inputvector[i + mid].num != returnedVec[i].num)
                {
                    throw new Exception("StructConstPtrVector test (3) failed, i:" + i);
                }
            }
        }

        // Test construction
        {
            string[] one_two_three = new string[] { "one", "two", "three" };

            // Test construction from array
            {
                string[] collection = one_two_three;
                check123(new StringVector(collection));
            }

            // Test construction from IEnumerable
            {
                global::System.Collections.IEnumerable collection = one_two_three;
                check123(new StringVector(collection));
            }

            // Test construction from IEnumerable<>
            {
                global::System.Collections.Generic.IEnumerable <string> collection = one_two_three;
                check123(new StringVector(collection));
            }

            // Test construction from IList<>
            {
                global::System.Collections.Generic.IList <string> collection = one_two_three;
                check123(new StringVector(collection));
            }

            // Test construction from ICollection
            {
                global::System.Collections.ICollection collection = one_two_three;
                check123(new StringVector(collection));
            }

            // Test construction from ICollection<>
            {
                global::System.Collections.Generic.ICollection <string> collection = new global::System.Collections.Generic.List <string>(one_two_three);
                check123(new StringVector(collection));
            }
        }
    }
示例#48
0
 partial void CreateNewDandDC_InitializeDataWorkspace(global::System.Collections.Generic.List <global::Microsoft.LightSwitch.IDataService> saveChangesTo)
 {
     // Write your code here.
     this.DandDCProperty = new DandDC();
 }
示例#49
0
 private global::System.Data.DataRow[] GetRealUpdatedRows(global::System.Data.DataRow[] updatedRows, global::System.Collections.Generic.List <global::System.Data.DataRow> allAddedRows)
 {
     if (((updatedRows == null) ||
          (updatedRows.Length < 1)))
     {
         return(updatedRows);
     }
     if (((allAddedRows == null) ||
          (allAddedRows.Count < 1)))
     {
         return(updatedRows);
     }
     global::System.Collections.Generic.List <global::System.Data.DataRow> realUpdatedRows = new global::System.Collections.Generic.List <global::System.Data.DataRow>();
     for (int i = 0; (i < updatedRows.Length); i = (i + 1))
     {
         global::System.Data.DataRow row = updatedRows[i];
         if ((allAddedRows.Contains(row) == false))
         {
             realUpdatedRows.Add(row);
         }
     }
     return(realUpdatedRows.ToArray());
 }
示例#50
0
 /// <summary>
 /// Returns a list of custom toolbox items to be added dynamically
 /// </summary>
 public virtual global::System.Collections.Generic.IList <DslDesign::ModelingToolboxItem> CreateToolboxItems()
 {
     global::System.Collections.Generic.List <DslDesign::ModelingToolboxItem> toolboxItems = new global::System.Collections.Generic.List <DslDesign::ModelingToolboxItem>();
     return(toolboxItems);
 }
 public static void CreateGenericList_0 <TItem>(global::Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder __builder, int seq, int __seq0, global::System.Collections.Generic.List <TItem> __arg0, int __seq1, global::Microsoft.AspNetCore.Components.RenderFragment __arg1)
 {
     __builder.OpenComponent <global::Movies_Blazor.Client.Shared.GenericList <TItem> >(seq);
     __builder.AddAttribute(__seq0, "List", __arg0);
     __builder.AddAttribute(__seq1, "WholeListTemplate", __arg1);
     __builder.CloseComponent();
 }
示例#52
0
        public virtual int UpdateAll(School_SystemDataSet3 dataSet)
        {
            if ((dataSet == null))
            {
                throw new global::System.ArgumentNullException("dataSet");
            }
            if ((dataSet.HasChanges() == false))
            {
                return(0);
            }
            global::System.Data.IDbConnection workConnection = this.Connection;
            if ((workConnection == null))
            {
                throw new global::System.ApplicationException("TableAdapterManager contains no connection information. Set each TableAdapterMana" +
                                                              "ger TableAdapter property to a valid TableAdapter instance.");
            }
            bool workConnOpened = false;

            if (((workConnection.State & global::System.Data.ConnectionState.Broken)
                 == global::System.Data.ConnectionState.Broken))
            {
                workConnection.Close();
            }
            if ((workConnection.State == global::System.Data.ConnectionState.Closed))
            {
                workConnection.Open();
                workConnOpened = true;
            }
            global::System.Data.IDbTransaction workTransaction = workConnection.BeginTransaction();
            if ((workTransaction == null))
            {
                throw new global::System.ApplicationException("The transaction cannot begin. The current data connection does not support transa" +
                                                              "ctions or the current state is not allowing the transaction to begin.");
            }
            global::System.Collections.Generic.List <global::System.Data.DataRow>                     allChangedRows = new global::System.Collections.Generic.List <global::System.Data.DataRow>();
            global::System.Collections.Generic.List <global::System.Data.DataRow>                     allAddedRows   = new global::System.Collections.Generic.List <global::System.Data.DataRow>();
            global::System.Collections.Generic.List <global::System.Data.Common.DataAdapter>          adaptersWithAcceptChangesDuringUpdate = new global::System.Collections.Generic.List <global::System.Data.Common.DataAdapter>();
            global::System.Collections.Generic.Dictionary <object, global::System.Data.IDbConnection> revertConnections = new global::System.Collections.Generic.Dictionary <object, global::System.Data.IDbConnection>();
            int result = 0;

            global::System.Data.DataSet backupDataSet = null;
            if (this.BackupDataSetBeforeUpdate)
            {
                backupDataSet = new global::System.Data.DataSet();
                backupDataSet.Merge(dataSet);
            }
            try {
                // ---- Prepare for update -----------
                //
                //
                //---- Perform updates -----------
                //
                if ((this.UpdateOrder == UpdateOrderOption.UpdateInsertDelete))
                {
                    result = (result + this.UpdateUpdatedRows(dataSet, allChangedRows, allAddedRows));
                    result = (result + this.UpdateInsertedRows(dataSet, allAddedRows));
                }
                else
                {
                    result = (result + this.UpdateInsertedRows(dataSet, allAddedRows));
                    result = (result + this.UpdateUpdatedRows(dataSet, allChangedRows, allAddedRows));
                }
                result = (result + this.UpdateDeletedRows(dataSet, allChangedRows));
                //
                //---- Commit updates -----------
                //
                workTransaction.Commit();
                if ((0 < allAddedRows.Count))
                {
                    global::System.Data.DataRow[] rows = new System.Data.DataRow[allAddedRows.Count];
                    allAddedRows.CopyTo(rows);
                    for (int i = 0; (i < rows.Length); i = (i + 1))
                    {
                        global::System.Data.DataRow row = rows[i];
                        row.AcceptChanges();
                    }
                }
                if ((0 < allChangedRows.Count))
                {
                    global::System.Data.DataRow[] rows = new System.Data.DataRow[allChangedRows.Count];
                    allChangedRows.CopyTo(rows);
                    for (int i = 0; (i < rows.Length); i = (i + 1))
                    {
                        global::System.Data.DataRow row = rows[i];
                        row.AcceptChanges();
                    }
                }
            }
            catch (global::System.Exception ex) {
                workTransaction.Rollback();
                // ---- Restore the dataset -----------
                if (this.BackupDataSetBeforeUpdate)
                {
                    global::System.Diagnostics.Debug.Assert((backupDataSet != null));
                    dataSet.Clear();
                    dataSet.Merge(backupDataSet);
                }
                else
                {
                    if ((0 < allAddedRows.Count))
                    {
                        global::System.Data.DataRow[] rows = new System.Data.DataRow[allAddedRows.Count];
                        allAddedRows.CopyTo(rows);
                        for (int i = 0; (i < rows.Length); i = (i + 1))
                        {
                            global::System.Data.DataRow row = rows[i];
                            row.AcceptChanges();
                            row.SetAdded();
                        }
                    }
                }
                throw ex;
            }
            finally {
                if (workConnOpened)
                {
                    workConnection.Close();
                }
                if ((0 < adaptersWithAcceptChangesDuringUpdate.Count))
                {
                    global::System.Data.Common.DataAdapter[] adapters = new System.Data.Common.DataAdapter[adaptersWithAcceptChangesDuringUpdate.Count];
                    adaptersWithAcceptChangesDuringUpdate.CopyTo(adapters);
                    for (int i = 0; (i < adapters.Length); i = (i + 1))
                    {
                        global::System.Data.Common.DataAdapter adapter = adapters[i];
                        adapter.AcceptChangesDuringUpdate = true;
                    }
                }
            }
            return(result);
        }
 public TrajectoryRawFeature()
 {
     point_feature = new global::System.Collections.Generic.List <TrajectoryPointRawFeature>();
     OnConstructor();
 }
示例#54
0
        private int UpdateDeletedRows(School_SystemDataSet3 dataSet, global::System.Collections.Generic.List <global::System.Data.DataRow> allChangedRows)
        {
            int result = 0;

            return(result);
        }
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__IScoreSnapshot);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "compareTo", "compareTo0", "(Ljava/lang/Object;)I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getName", "getName1", "()Ljava/lang/String;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalScore", "getTotalScore2", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalSurvivalScore", "getTotalSurvivalScore3", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalLastSurvivorBonus", "getTotalLastSurvivorBonus4", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalBulletDamageScore", "getTotalBulletDamageScore5", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalBulletKillBonus", "getTotalBulletKillBonus6", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalRammingDamageScore", "getTotalRammingDamageScore7", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalRammingKillBonus", "getTotalRammingKillBonus8", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalFirsts", "getTotalFirsts9", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalSeconds", "getTotalSeconds10", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTotalThirds", "getTotalThirds11", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentScore", "getCurrentScore12", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentSurvivalScore", "getCurrentSurvivalScore13", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentSurvivalBonus", "getCurrentSurvivalBonus14", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentBulletDamageScore", "getCurrentBulletDamageScore15", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentBulletKillBonus", "getCurrentBulletKillBonus16", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentRammingDamageScore", "getCurrentRammingDamageScore17", "()D"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getCurrentRammingKillBonus", "getCurrentRammingKillBonus18", "()D"));
     return(methods);
 }
示例#56
0
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__ITurnSnapshot);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getRobots", "getRobots0", "()[Lrobocode/control/snapshot/IRobotSnapshot;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getBullets", "getBullets1", "()[Lrobocode/control/snapshot/IBulletSnapshot;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTPS", "getTPS2", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getRound", "getRound3", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getTurn", "getTurn4", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getSortedTeamScores", "getSortedTeamScores5", "()[Lrobocode/control/snapshot/IScoreSnapshot;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getIndexedTeamScores", "getIndexedTeamScores6", "()[Lrobocode/control/snapshot/IScoreSnapshot;"));
     return(methods);
 }
示例#57
0
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__QueryResults);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "iterator", "iterator0", "()Ljava/util/Iterator;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "size", "size1", "()I"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getIdentifiers", "getIdentifiers2", "()[Ljava/lang/String;"));
     return(methods);
 }
示例#58
0
 private static global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> @__Init(global::net.sf.jni4net.jni.JNIEnv @__env, global::java.lang.Class @__class)
 {
     global::System.Type @__type = typeof(__ProcessContext);
     global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod> methods = new global::System.Collections.Generic.List <global::net.sf.jni4net.jni.JNINativeMethod>();
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getKnowledgeRuntime", "getKnowledgeRuntime0", "()Lorg/drools/runtime/KnowledgeRuntime;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getProcessInstance", "getProcessInstance1", "()Lorg/drools/runtime/process/ProcessInstance;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getVariable", "getVariable2", "(Ljava/lang/String;)Ljava/lang/Object;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "getNodeInstance", "getNodeInstance3", "()Lorg/drools/runtime/process/NodeInstance;"));
     methods.Add(global::net.sf.jni4net.jni.JNINativeMethod.Create(@__type, "setVariable", "setVariable4", "(Ljava/lang/String;Ljava/lang/Object;)V"));
     return(methods);
 }
示例#59
0
 public PerceptionLanes()
 {
     camera_laneline = new global::System.Collections.Generic.List <global::apollo.perception.camera.CameraLaneLine>();
     OnConstructor();
 }
示例#60
0
/// <summary>
/// Initialize the template
/// </summary>
        public override void Initialize()
        {
            base.Initialize();
            if ((this.Errors.HasErrors == false))
            {
                bool DebugCallbackValueAcquired = false;
                if (this.Session.ContainsKey("DebugCallback"))
                {
                    this._DebugCallbackField   = ((global::System.EventHandler)(this.Session["DebugCallback"]));
                    DebugCallbackValueAcquired = true;
                }
                if ((DebugCallbackValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("DebugCallback");
                    if ((data != null))
                    {
                        this._DebugCallbackField = ((global::System.EventHandler)(data));
                    }
                }
                bool ImportsValueAcquired = false;
                if (this.Session.ContainsKey("Imports"))
                {
                    this._ImportsField   = ((global::System.Collections.Generic.IEnumerable <ModuleImportDeclaration>)(this.Session["Imports"]));
                    ImportsValueAcquired = true;
                }
                if ((ImportsValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Imports");
                    if ((data != null))
                    {
                        this._ImportsField = ((global::System.Collections.Generic.IEnumerable <ModuleImportDeclaration>)(data));
                    }
                }
                bool ExportsValueAcquired = false;
                if (this.Session.ContainsKey("Exports"))
                {
                    this._ExportsField   = ((global::System.Collections.Generic.List <ESModule>)(this.Session["Exports"]));
                    ExportsValueAcquired = true;
                }
                if ((ExportsValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Exports");
                    if ((data != null))
                    {
                        this._ExportsField = ((global::System.Collections.Generic.List <ESModule>)(data));
                    }
                }
                bool DeclarationsValueAcquired = false;
                if (this.Session.ContainsKey("Declarations"))
                {
                    this._DeclarationsField   = ((global::System.Collections.Generic.List <IDeclarable>)(this.Session["Declarations"]));
                    DeclarationsValueAcquired = true;
                }
                if ((DeclarationsValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Declarations");
                    if ((data != null))
                    {
                        this._DeclarationsField = ((global::System.Collections.Generic.List <IDeclarable>)(data));
                    }
                }
                bool UILoadKindValueAcquired = false;
                if (this.Session.ContainsKey("UILoadKind"))
                {
                    this._UILoadKindField   = ((global::AbstraX.DataAnnotations.UILoadKind)(this.Session["UILoadKind"]));
                    UILoadKindValueAcquired = true;
                }
                if ((UILoadKindValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("UILoadKind");
                    if ((data != null))
                    {
                        this._UILoadKindField = ((global::AbstraX.DataAnnotations.UILoadKind)(data));
                    }
                }
                bool PageNameValueAcquired = false;
                if (this.Session.ContainsKey("PageName"))
                {
                    this._PageNameField   = ((string)(this.Session["PageName"]));
                    PageNameValueAcquired = true;
                }
                if ((PageNameValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("PageName");
                    if ((data != null))
                    {
                        this._PageNameField = ((string)(data));
                    }
                }
                bool AuthorizeValueAcquired = false;
                if (this.Session.ContainsKey("Authorize"))
                {
                    this._AuthorizeField   = ((string)(this.Session["Authorize"]));
                    AuthorizeValueAcquired = true;
                }
                if ((AuthorizeValueAcquired == false))
                {
                    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Authorize");
                    if ((data != null))
                    {
                        this._AuthorizeField = ((string)(data));
                    }
                }
            }
        }