static void Main() { Type obj = Type.GetType(ConfigurationManager.AppSettings["UserRepository"]); System.Reflection.ConstructorInfo constructor = obj.GetConstructor(new Type[] { }); IUserDAO userRepository = (IUserDAO)constructor.Invoke(null); UserService userService = new UserService(userRepository); obj = Type.GetType(ConfigurationManager.AppSettings["ServiciuRepository"]); constructor = obj.GetConstructor(new Type[] { }); IServiciuDAO serviciuRepository = (IServiciuDAO)constructor.Invoke(null); ServiciuService serviciuServer = new ServiciuService(serviciuRepository); obj = Type.GetType(ConfigurationManager.AppSettings["ProgramareServiciuRepository"]); constructor = obj.GetConstructor(new Type[] { }); IProgramareServiciuDAO programareServiciuRepository = (IProgramareServiciuDAO)constructor.Invoke(null); obj = Type.GetType(ConfigurationManager.AppSettings["ProgramareRepository"]); constructor = obj.GetConstructor(new Type[] { }); IProgramareDAO programareRepository = (IProgramareDAO)constructor.Invoke(null); ProgramareService programareService = new ProgramareService(programareRepository, serviciuRepository, programareServiciuRepository); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new LoginForm(userService, serviciuServer, programareService)); }
private SchedulerClient GetSchedulerClient(string strProcess, ScheduleHistoryItem objScheduleHistoryItem) { try { // '''''''''''''''''''''''''''''''''''''''''''''''''' // This is a method to encapsulate returning // an object whose class inherits SchedulerClient. // '''''''''''''''''''''''''''''''''''''''''''''''''' // Return value SchedulerClient objRetClient = null; // The constructor we've found System.Reflection.ConstructorInfo objConstructor = null; // The type we need Type t = Type.GetType(strProcess, true); // '''''''''''''''''''''''''''''''''''''''''''''''''' // Get the default constructor for the class // '''''''''''''''''''''''''''''''''''''''''''''''''' objConstructor = t.GetConstructor(System.Type.EmptyTypes); if (null != objConstructor) { // Found the default constructor objRetClient = (SchedulerClient)objConstructor.Invoke(null); } else { // '''''''''''''''''''''''''''''''''''''''''''''''''' // Get the parameterised constructor for the class // '''''''''''''''''''''''''''''''''''''''''''''''''' // Parameters we pass to the constructor ScheduleHistoryItem[] param = new ScheduleHistoryItem[1]; param[0] = objScheduleHistoryItem; // Parameter types we pass to the constructor Type[] types = new Type[1]; types[0] = typeof(ScheduleHistoryItem); // Get the parameterised contructor objConstructor = t.GetConstructor(types); // Call the constructor objRetClient = (SchedulerClient)objConstructor.Invoke(param); } // '''''''''''''''''''''''''''''''''''''''''''''''''' // Return an instance of the class as an object // '''''''''''''''''''''''''''''''''''''''''''''''''' return(objRetClient); } catch (Exception exc) { //Exceptions.ProcessSchedulerException(exc); throw exc; } return(null); }
/// <summary> Create a channel with the given capacity and /// semaphore implementations instantiated from the supplied class /// </summary> public SemaphoreControlledChannel(int capacity, System.Type semaphoreClass) { if (capacity <= 0) { throw new System.ArgumentException(); } capacity_ = capacity; System.Type[] longarg = new System.Type[] { System.Type.GetType("System.Int64") }; System.Reflection.ConstructorInfo ctor = semaphoreClass.GetConstructor(System.Reflection.BindingFlags.DeclaredOnly, null, longarg, null); object [] cap = new object [] { (System.Int64)capacity }; putGuard_ = (Semaphore)(ctor.Invoke(cap)); object [] zero = new object [] { (System.Int64) 0 }; takeGuard_ = (Semaphore)(ctor.Invoke(zero)); }
public List <IMigration> GetAllMigrations(string connectionString) { CollectibleAssemblyLoadContext context = new CollectibleAssemblyLoadContext(_pluginConfiguration.Name); string assemblyPath = Path.Combine(_tempFolderName, $"{_pluginConfiguration.Name}.dll"); using (FileStream fs = new FileStream(assemblyPath, FileMode.Open, FileAccess.Read)) { System.Reflection.Assembly assembly = context.LoadFromStream(fs); IEnumerable <Type> migrationTypes = assembly.ExportedTypes.Where(p => p.GetInterfaces().Contains(typeof(IMigration))); List <IMigration> migrations = new List <IMigration>(); foreach (Type migrationType in migrationTypes) { System.Reflection.ConstructorInfo constructor = migrationType.GetConstructors().First(p => p.GetParameters().Count() == 1 && p.GetParameters()[0].ParameterType == typeof(IDbHelper)); migrations.Add((IMigration)constructor.Invoke(new object[] { _dbHelper })); } context.Unload(); GC.Collect(); GC.WaitForPendingFinalizers(); return(migrations.OrderBy(p => p.Version).ToList()); } }
/// <summary> /// Создает произвольный диалог для класса из доменной модели приложения. /// </summary> /// <returns>Виджет с интерфейсом ITdiDialog</returns> /// <param name="objectClass">Класс объекта для которого нужно создать диалог.</param> /// <param name="parameters">Параметры конструктора диалога.</param> public static ITdiDialog CreateObjectDialog(System.Type objectClass, params object[] parameters) { System.Type dlgType = GetDialogType(objectClass); if (dlgType == null) { InvalidOperationException ex = new InvalidOperationException( String.Format("Для класса {0} нет привязанного диалога.", objectClass)); logger.Error(ex); throw ex; } Type[] paramTypes = new Type[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { paramTypes[i] = parameters[i].GetType(); } System.Reflection.ConstructorInfo ci = dlgType.GetConstructor(paramTypes); if (ci == null) { InvalidOperationException ex = new InvalidOperationException( String.Format("Конструктор для диалога {0} с параметрами({1}) не найден.", dlgType.ToString(), NHibernate.Util.CollectionPrinter.ToString(paramTypes))); logger.Error(ex); throw ex; } logger.Debug("Вызываем конструктор диалога {0} c параметрами {1}.", dlgType.ToString(), NHibernate.Util.CollectionPrinter.ToString(paramTypes)); return((ITdiDialog)ci.Invoke(parameters)); }
private object InstantiatePlugin(Hashtable plugins, String type) { Type pluginType = (Type)plugins[type]; System.Reflection.ConstructorInfo info = pluginType.GetConstructor(new Type[] {}); return(info.Invoke(new object[] {})); }
public static tydisasm GetDisassembler(string arch) { System.Type[] types = typeof(tydisasm).Assembly.GetTypes(); System.Type t = null; foreach (System.Type test in types) { if (test.Name == (arch + "_disasm")) { t = test; break; } } if (t == null) { return(null); } System.Reflection.ConstructorInfo ctor = t.GetConstructor(System.Type.EmptyTypes); if (ctor == null) { return(null); } tydisasm ret = ctor.Invoke(null) as tydisasm; return(ret); }
public CciInterface(string pefilename) { object dh = ctor_DefaultHost.Invoke(new object[] { }); pdb = ctor_PdbReader_Stream_IMetadataHost.Invoke(new object[] { new FileStream(Path.ChangeExtension(pefilename, "pdb"), FileMode.Open), dh }); tok_dev = meth_MetadataReaderHost_LoadUnitFrom_string.Invoke(dh, new object[] { pefilename }); }
/// <summary> /// 获取实现 IHtmlContext 接口的 GetContext 方法的内容。 /// </summary> /// <param name="typeName">类型名称</param> /// <param name="parameter">参数</param> /// <param name="callback">HTML 页面中回调方法的名称</param> public void GetHtmlContext(string typeName, string parameter, string callback) { Type typ = Function.GetType(typeName); if (typ != null) { try { System.Reflection.ConstructorInfo ciObject = typ.GetConstructor(new System.Type[] { }); object obj = ciObject.Invoke(new object[] { }); IHtmlContext _IHtmlContext = obj as IHtmlContext; if (_IHtmlContext is IUseAccount) { IUseAccount _IUseAccount = _IHtmlContext as IUseAccount; _IUseAccount.SetAccount(this.PluginView.Application.CurrentAccount); } this.PluginView.SetHtmlContext(callback, true, _IHtmlContext.GetContext(this.PluginView.Application, parameter)); } catch (Exception ex) { this.PluginView.SetHtmlContext(callback, false, ex.Message); } } else { MessageBox.Show("无法加载名称为“" + typeName + "”的类型", "获取内容", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public object GetInstance(InstanceContext instanceContext) { System.Reflection.ConstructorInfo cinfo = syncServiceType.GetConstructor(new Type[] { typeof(String), typeof(System.Net.NetworkCredential) }); if (cinfo == null) { throw new Exception(String.Format("Type {0} does not implement String parameter constructor", syncServiceType.ToString())); } else { try { return(cinfo.Invoke(new object[] { name, GetCredentials() })); } catch (Exception e) { if (e.InnerException is UnauthorizedAccessException) { WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.Unauthorized; WebOperationContext.Current.OutgoingResponse.StatusDescription = e.InnerException.Message; return(null); //throw new System.Web.HttpException(401, e.Message); } throw e; } } }
/// <summary> /// Call method of given class using provided arguments. /// </summary> /// <param name="class_name">Class name</param> /// <param name="args0">Constructor args</param> /// <param name="method_name">Method name</param> /// <param name="args">List of arguments</param> /// <returns>Result of method execution</returns> public static Object CallMethod(String class_name, TArrayList args0, String method_name, TArrayList args) { Type type = Type.GetType(class_name.Replace('/', '.')); Type[] types0 = GetTypes(args0); System.Reflection.ConstructorInfo constructorInfo = type.GetConstructor(types0); Object doObject = constructorInfo.Invoke(args0.ToArray()); Type[] types = GetTypes(args); System.Reflection.MethodInfo methodInfo = type.GetMethod(method_name, types); if (methodInfo != null) { if (args != null && args.Size() > 0) { return(methodInfo.Invoke(doObject, args.ToArray())); } else { return(methodInfo.Invoke(doObject, null)); } } else { return(null); } }
/// <summary> /// Creates a version-specific MSH object and returns it as a version-independent MSH interface. /// throws HL7Exception if there is a problem, e.g. invalid version, code not available for given /// version. /// </summary> /// /// <exception cref="HL7Exception"> Thrown when a HL 7 error condition occurs. </exception> /// /// <param name="version"> . </param> /// <param name="factory"> The factory. </param> /// /// <returns> An ISegment. </returns> public static ISegment MakeControlMSH(System.String version, IModelClassFactory factory) { ISegment msh = null; try { IMessage dummy = (IMessage) GenericMessage.getGenericMessageClass(version) .GetConstructor(new[] { typeof(IModelClassFactory) }) .Invoke(new System.Object[] { factory }); System.Type[] constructorParamTypes = { typeof(IGroup), typeof(IModelClassFactory) }; System.Object[] constructorParamArgs = { dummy, factory }; System.Type c = factory.GetSegmentClass("MSH", version); System.Reflection.ConstructorInfo constructor = c.GetConstructor(constructorParamTypes); msh = (ISegment)constructor.Invoke(constructorParamArgs); } catch (System.Exception e) { throw new HL7Exception( "Couldn't create MSH for version " + version + " (does your classpath include this version?) ... ", HL7Exception.APPLICATION_INTERNAL_ERROR, e); } return(msh); }
//该任务的图标和照片。 private IIcon GetImages(Type taskType) { if (taskType.GetCustomAttributes(typeof(TaskTypeAttribute), false).Length > 0) { TaskTypeAttribute attr = (TaskTypeAttribute)taskType.GetCustomAttributes(typeof(TaskTypeAttribute), false)[0]; if (attr.ImageType != null && attr.ImageType.GetInterface(typeof(IIcon).FullName) != null) { System.Reflection.ConstructorInfo ci = attr.ImageType.GetConstructor(new System.Type[] { }); object objInstance = ci.Invoke(new object[] { }); return(objInstance as IIcon); } else { if (taskType.BaseType != typeof(Task) && taskType.BaseType.IsAbstract == false) { return(GetImages(taskType.BaseType)); } else { return(null); } } } else { return(null); } }
private object Create(Type type) { if (implementations.ContainsKey(type)) { return(implementations[type]); } var availableTypes = types[type]; System.Reflection.ConstructorInfo defConstructor = availableTypes.GetConstructors()[0]; System.Reflection.ParameterInfo[] defParams = defConstructor.GetParameters(); var parameters = defParams.Select(param => { if (implementations.ContainsKey(param.GetType())) { return(implementations[param.GetType()]); } else { return(Create(param.ParameterType)); } }).ToArray(); return(defConstructor.Invoke(parameters)); }
/// <summary> /// 创建当前设备类型的驱动对象,如该设备无驱动则返回 null。 /// </summary> /// <returns></returns> internal IDrive CreateDrive() { System.Reflection.ConstructorInfo ci = this.DriveType.GetConstructor(new System.Type[] { }); object objInstance = ci.Invoke(new object[] { }); return(objInstance as IDrive); }
public void RestoreSaveData(TaskSaveData_v1 data) { // Restore base task data symbol = data.symbol; targetSymbol = data.targetSymbol; IsTriggered = data.triggered; prevTriggered = data.prevTriggered; type = data.type; dropped = data.dropped; globalVarName = data.globalVarName; globalVarLink = data.globalVarLink; hasTriggerConditions = data.hasTriggerConditions; // Restore actions actions.Clear(); foreach (ActionTemplate.ActionSaveData_v1 actionData in data.actions) { // Construct deserialized QuestAction based on type System.Reflection.ConstructorInfo ctor = actionData.type.GetConstructor(new Type[] { typeof(Quest) }); ActionTemplate action = (ActionTemplate)ctor.Invoke(new object[] { ParentQuest }); // Restore state action.RestoreActionSaveData(actionData); actions.Add(action); } }
public static LayerResource Create(Type type) { System.Reflection.ConstructorInfo ci = type.GetConstructor(new Type[] { }); LayerResource res = (LayerResource)ci.Invoke(new object[] { }); return(res); }
private Object instancePlayerForTimeline(String timelineType) { try { String typeName = ns + timelineType + "Player"; Type t = Type.GetType(typeName); if (t == null) { return(null); } System.Reflection.ConstructorInfo ctor = t.GetConstructor(argTypes); if (ctor == null) { return(null); } Object[] argValues = new Object[] { this.globe }; return(ctor.Invoke(argValues)); } catch (Exception e) { throw new TimelineException("Error constructing script player for " + timelineType + ".", e); } }
public static ImpresorElemento InstanciarImpresor(Lbl.IElementoDeDatos elemento, IDbTransaction transaction) { Type tipo = InferirImpresor(elemento.GetType()); System.Reflection.ConstructorInfo TConstr = tipo.GetConstructor(new Type[] { typeof(Lbl.ElementoDeDatos), typeof(IDbTransaction) }); return((ImpresorElemento)(TConstr.Invoke(new object[] { elemento, transaction }))); }
private IList <FilesComparator> GetComparators(string sampleRoot, string resultsRoot, string samplePath, bool debug) { IList <FilesComparator> comparators = new List <FilesComparator>(); foreach (var names in Names) { Paths path = new Paths(sampleRoot, resultsRoot, samplePath, names); if (System.IO.File.Exists(path.Result)) { Type type = names.GetComparatorType(); var isEI = names.IsEI(); System.Reflection.ConstructorInfo constructor = type.GetConstructor(new[] { typeof(Paths), typeof(bool), typeof(bool) }); comparators.Add((FilesComparator)constructor?.Invoke(new object[] { path, debug, isEI })); } } #if EUROINFO_RULES if (comparators.Any(c => c.IsEI)) { //If any -EI result file exists => Remove all comparators without isEI flag to true. //We only want to check EI results files. foreach (var comparatorToRemove in comparators.Where(c => !(c.IsEI)).ToList()) { comparators.Remove(comparatorToRemove); } } #endif return(comparators); }
static internal bool Create() { if (Program.arch_name == null) { throw new Exception("architecture not selected"); } try { Type archt = Type.GetType("tydb." + Program.arch_name + "_dbgarch", false, true); System.Reflection.ConstructorInfo ctorm = archt.GetConstructor(new Type[] { }); if (ctorm == null) { throw new TypeLoadException(); } Program.arch = ctorm.Invoke(new object[] { }) as dbgarch; } catch (Exception e) { if (e is TypeLoadException) { Console.WriteLine(Program.arch_name + " is not a valid debug architecture"); Console.WriteLine(); return(false); } throw; } if (Program.arch.Init(Program.feature_list.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))) { //Program.arch.ass.search_dirs = Program.lib_dirs; return(true); } return(false); }
void _dhcpv4Client_IpConfigChanged(object sender, uint ipAddress, uint gatewayAddress, uint subnetMask) { _ipv4configIPAddress = ipAddress; _ipv4configSubnetMask = subnetMask; _ipv4configGatewayAddress = gatewayAddress; _arpResolver.SetIpv4Address(_ipv4configIPAddress); /*** TODO: we should re-send our gratuitious (or probe) ARP every time that our IP address changes (via DHCP or otherwise), and also every time our network link goes up ***/ /*** TODO: if our IP address changes, should we update the source IP address on all of our sockets? Should we close any active connection-based sockets? ***/ Type networkChangeListenerType = Type.GetType("Microsoft.SPOT.Net.NetworkInformation.NetworkChange+NetworkChangeListener, Microsoft.SPOT.Net"); if (networkChangeListenerType != null) { // create instance of NetworkChangeListener System.Reflection.ConstructorInfo networkChangeListenerConstructor = networkChangeListenerType.GetConstructor(new Type[] { }); object networkChangeListener = networkChangeListenerConstructor.Invoke(new object[] { }); // now call the ProcessEvent function to create a NetworkEvent class. System.Reflection.MethodInfo processEventMethodType = networkChangeListenerType.GetMethod("ProcessEvent"); object networkEvent = processEventMethodType.Invoke(networkChangeListener, new object[] { (UInt32)(((UInt32)2 /* AddressChanged*/)), (UInt32)0, DateTime.Now }); /* TODO: should this be DateTime.Now or DateTime.UtcNow? */ // and finally call the static NetworkChange.OnNetworkChangeCallback function to raise the event. Type networkChangeType = Type.GetType("Microsoft.SPOT.Net.NetworkInformation.NetworkChange, Microsoft.SPOT.Net"); if (networkChangeType != null) { System.Reflection.MethodInfo onNetworkChangeCallbackMethod = networkChangeType.GetMethod("OnNetworkChangeCallback", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic); onNetworkChangeCallbackMethod.Invoke(networkChangeType, new object[] { networkEvent }); } } }
private static object CoerceObject(object value, Type to) { if (value == null) { return(null); } var result = value; if (typeof(Select).IsAssignableFrom(to)) { var ctorChain = new List <System.Reflection.ConstructorInfo>(); System.Reflection.ConstructorInfo ctor = null; if (STEPListener.TypeHasConstructorForSelectChoice(to, value.GetType(), out ctor, ref ctorChain)) { result = ctor.Invoke(new object[] { value }); if (ctorChain.Any()) { // Construct the necessary wrappers working // backwards. For the first constructor, the parameter // will be the constructed instance. for (var y = ctorChain.Count - 1; y >= 0; y--) { result = ctorChain[y].Invoke(new object[] { result }); } } } } return(result); }
BaseTest InitCurrentTest(TestInfo testInfo, Type[] types, object[] args) { // find constructor. Type t = testInfo.Method.DeclaringType; System.Reflection.ConstructorInfo ci = t.GetConstructor( System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance, null, System.Reflection.CallingConventions.HasThis, types, null); // Create object object itObject = ci.Invoke(args); BaseTest test = (BaseTest)itObject; _currentTest = test; // subscribe to test events. SubscribeToTestEvents(test); if (testInfo.ProcessType == ProcessType.FeatureDefinition) { FeaturesDefinitionProcess fdp = (FeaturesDefinitionProcess)test; fdp.FeatureDefined += new Action <Feature, bool>(fdp_FeatureDefined); fdp.FeatureDefinitionFailed += new Action <Feature>(fdp_FeatureDefinitionFailed); fdp.ScopeDefined += new Action <string>(fdp_ScopeDefined); fdp.DeviceInformationReceived += new Action <DeviceInformation>(fdp_DeviceInformationReceived); } _currentTest.EntryPoint = testInfo.Method; return(test); }
/// <summary> /// Creates one new blank chunk of the corresponding type, according to factoryMap (PngChunkUNKNOWN if not known) /// </summary> /// <param name="cid">Chunk Id</param> /// <param name="info"></param> /// <returns></returns> internal static PngChunk FactoryFromId(String cid, ImageInfo info) { PngChunk chunk = null; if (factoryMap == null) { initFactory(); } if (isKnown(cid)) { Type t = factoryMap[cid]; if (t == null) { Console.Error.WriteLine("What?? " + cid); } System.Reflection.ConstructorInfo cons = t.GetConstructor(new Type[] { typeof(ImageInfo) }); object o = cons.Invoke(new object[] { info }); chunk = (PngChunk)o; } if (chunk == null) { chunk = new PngChunkUNKNOWN(cid, info); } return(chunk); }
public MyFile OpenFile(string filePath, string fileExtension, TextRange doc) { MyFile file = new MyFile { Extension = fileExtension }; Type TestType = Type.GetType("PaternExamNew." + fileExtension.ToUpper(), false, true); //если класс не найден if (TestType != null) { //получаем конструктор System.Reflection.ConstructorInfo ci = TestType.GetConstructor(new Type[] { }); //вызываем конструтор object Obj = ci.Invoke(new object[] { }); file.SetStrategy(Obj as IStrategy); } else { MessageBox.Show("Расширение не поддерживается"); } file.Open(doc); Files.Add(file); CurrentFileId = Files.Count - 1; return(Files[CurrentFileId]); }
public void RestoreSaveData(QuestSaveData_v1 data) { // Restore base state uid = data.uid; questComplete = data.questComplete; questSuccess = data.questSuccess; questName = data.questName; displayName = data.displayName; factionId = data.factionId; questStartTime = data.questStartTime; questTombstoned = data.questTombstoned; questTombstoneTime = data.questTombstoneTime; smallerDungeonsState = data.smallerDungeonsState; compiledByVersion = data.compiledByVersion; // Restore active log messages activeLogMessages.Clear(); foreach (LogEntry logEntry in data.activeLogMessages) { activeLogMessages.Add(logEntry.stepID, logEntry); } // Restore messages messages.Clear(); foreach (Message.MessageSaveData_v1 messageData in data.messages) { Message message = new Message(this); message.RestoreSaveData(messageData); messages.Add(message.ID, message); } // Restore resources resources.Clear(); foreach (QuestResource.ResourceSaveData_v1 resourceData in data.resources) { // Construct deserialized QuestResource based on type System.Reflection.ConstructorInfo ctor = resourceData.type.GetConstructor(new Type[] { typeof(Quest) }); QuestResource resource = (QuestResource)ctor.Invoke(new object[] { this }); // Restore state resource.RestoreResourceSaveData(resourceData); resources.Add(resource.Symbol.Name, resource); } // Restore questors questors.Clear(); if (data.questors != null) { questors = data.questors; } // Restore tasks tasks.Clear(); foreach (Task.TaskSaveData_v1 taskData in data.tasks) { Task task = new Task(this); task.RestoreSaveData(taskData); tasks.Add(task.Symbol.Name, task); } }
public void addArc(string name, Type arcType, node fromNode, node toNode) { if (arcType == null) { addArc(name, fromNode, toNode); } else { Type[] types = new Type[3]; types[0] = typeof(string); types[1] = typeof(node); types[2] = typeof(node); System.Reflection.ConstructorInfo arcConstructor = arcType.GetConstructor(types); object[] inputs = new object[3]; inputs[0] = name; inputs[1] = fromNode; inputs[2] = toNode; arcs.Add((arc)arcConstructor.Invoke(inputs)); if (fromNode != null) { fromNode.arcs.Add(arcs[lastArc]); fromNode.arcsFrom.Add(arcs[lastArc]); } if (toNode != null) { toNode.arcs.Add(arcs[lastArc]); toNode.arcsTo.Add(arcs[lastArc]); } } }
/// <summary>User can override to do their own debugging /// </summary> protected internal virtual void setupDebugging(TokenStream lexer, TokenBuffer tokenBuf) { setDebugMode(true); // default parser debug setup is ParseView try { try { System.Type.GetType("javax.swing.JButton"); } catch (System.Exception) { System.Console.Error.WriteLine("Swing is required to use ParseView, but is not present in your CLASSPATH"); System.Environment.Exit(1); } System.Type c = System.Type.GetType("antlr.parseview.ParseView"); System.Reflection.ConstructorInfo constructor = c.GetConstructor(new System.Type[] { typeof(LLkDebuggingParser), typeof(TokenStream), typeof(TokenBuffer) }); constructor.Invoke(new object[] { this, lexer, tokenBuf }); } catch (System.Exception e) { System.Console.Error.WriteLine("Error initializing ParseView: " + e); System.Console.Error.WriteLine("Please report this to Scott Stanchfield, [email protected]"); System.Environment.Exit(1); } }
/// <summary> Note that the validation context of the resulting message is set to this parser's validation /// context. The validation context is used within Primitive.setValue(). /// /// </summary> /// <param name="name">name of the desired structure in the form XXX_YYY /// </param> /// <param name="version">HL7 version (e.g. "2.3") /// </param> /// <param name="isExplicit">true if the structure was specified explicitly in MSH-9-3, false if it /// was inferred from MSH-9-1 and MSH-9-2. If false, a lookup may be performed to find /// an alternate structure corresponding to that message type and event. /// </param> /// <returns> a Message instance /// </returns> /// <throws> HL7Exception if the version is not recognized or no appropriate class can be found or the Message </throws> /// <summary> class throws an exception on instantiation (e.g. if args are not as expected) /// </summary> protected internal virtual Message instantiateMessage(System.String theName, System.String theVersion, bool isExplicit) { Message result = null; try { System.Type messageClass = myFactory.getMessageClass(theName, theVersion, isExplicit); if (messageClass == null) { //UPGRADE_NOTE: Exception 'java.lang.ClassNotFoundException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'" throw new System.Exception("Can't find message class in current package list: " + theName); } //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Class.getName' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" log.info("Instantiating msg of class " + messageClass.FullName); System.Reflection.ConstructorInfo constructor = messageClass.GetConstructor(new System.Type[] { typeof(ModelClassFactory) }); result = (Message)constructor.Invoke(new System.Object[] { myFactory }); } catch (System.Exception e) { throw new HL7Exception("Couldn't create Message object of type " + theName, HL7Exception.UNSUPPORTED_MESSAGE_TYPE, e); } result.ValidationContext = myContext; return(result); }