public string Validate(IDictionaryAdapter dictionaryAdapter) { List <string> errors = new List <string>(); var globalRules = AttributesUtil.GetTypeAttributes <ValidationRuleAttribute>( dictionaryAdapter.Meta.Type ); foreach (var property in dictionaryAdapter.This.Properties.Values) { var propertyRules = AttributesUtil .GetAttributes <ValidationRuleAttribute>(property.Property) .Select(x => (IValidationRule)x); var propertyValue = dictionaryAdapter.GetProperty(property.PropertyName, true); ApplyValidationRules( dictionaryAdapter, propertyRules, property, propertyValue, errors ); ApplyValidationRules( dictionaryAdapter, globalRules, property, propertyValue, errors ); } return(string.Join(Environment.NewLine, errors.ToArray())); }
private static PropertyInfo[] GetManagedProperties(object mobInstance) { var properties = mobInstance.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(property => AttributesUtil.HasAttribute <ManagedPropertyAttribute>(property)) .ToArray(); return(properties); }
private void ObtainTypeConverter() { var converterType = AttributesUtil.GetTypeConverter(Property); TypeConverter = (converterType != null) ? (TypeConverter)Activator.CreateInstance(converterType) : TypeDescriptor.GetConverter(PropertyType); }
public void ProcessModel(IKernel kernel, ComponentModel model) { var cachedMethods = model.Implementation.GetMethods().Where(m => AttributesUtil.GetAttribute <LoggingAttribute>(m) != null).ToList(); if (cachedMethods.Any()) { model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType <LoggingInterceptor>()); } }
public string Validate(IDictionaryAdapter dictionaryAdapter, PropertyDescriptor property) { List <String> errors = new List <string>(); var globalRules = AttributesUtil.GetTypeAttributes <IValidationRule>(dictionaryAdapter.Meta.Type); var propertyRules = AttributesUtil.GetAttributes <IValidationRule>(property.Property); var propertyValue = dictionaryAdapter.GetProperty(property.PropertyName, true); ApplyValidationRules(dictionaryAdapter, propertyRules, property, propertyValue, errors); ApplyValidationRules(dictionaryAdapter, globalRules, property, propertyValue, errors); return(String.Join(Environment.NewLine, errors.ToArray())); }
public IEnumerable <ServiceInfo> GetServicesFrom(Type type) { ServiceAttribute atr = AttributesUtil.GetAttribute <ServiceAttribute>(type); if (atr.ContractName == this.annotation) { return new[] { new ServiceInfo(typeof(IService), type, Lifetime.Instance) } } ; return(new ServiceInfo[] {}); } }
public EventEditorFactoryImp() { this.eventEditors = new List <EventEditor> (); var methods = AttributesUtil.GetMethodsWith <GameEventAttribute>(typeof(EventedEventManager), true); foreach (var m in methods) { this.eventEditors.Add(new AttributeEventEditor(new GameEventConfig(m.Key, m.Value))); } /*this.eventEditors.Add (new ChangeSwitchEventEditor ()); * this.eventEditors.Add (new AddItemEditor ()); * this.eventEditors.Add(new MoveEventEditor()); */ this.defaultEventEditor = new DefaultEventEditor(); }
private Dictionary <string, Type> GetPossibleCreations() { if (possibleCreationsCache == null) { possibleCreationsCache = new Dictionary <string, Type>(); // Make sure is a DOMWriter var contents = AttributesUtil.GetTypesWith <NodeContentAttribute>(true).Where(t => (typeof(Checkable)).IsAssignableFrom(t)); foreach (var content in contents) { foreach (var attr in content.GetCustomAttributes(typeof(NodeContentAttribute), true)) { var nodeContent = attr as NodeContentAttribute; var name = nodeContent.Name == string.Empty ? content.ToString() : nodeContent.Name; possibleCreationsCache.Add(name, content); } } } return(possibleCreationsCache); }
private static IEnumerable <T> GetPropertyBehaviors <T>(MemberInfo member) where T : class { return(AttributesUtil.GetAttributes <T>(member)); }
private static IEnumerable <T> GetInterfaceBehaviors <T>(Type type) where T : class { return(AttributesUtil.GetTypeAttributes <T>(type)); }
static int Main(string[] args) { bool shouldShowHelp = false; string robot_info_file = null; string robot_name = null; bool wait_signal = false; bool electric_gripper = false; bool vacuum_gripper = false; string gripper_info_file = null; string gripper_name = null; var options = new OptionSet { { "robot-info-file=", "the robot info YAML file", n => robot_info_file = n }, { "robot-name=", "override the robot device name", n => robot_name = n }, { "h|help", "show this message and exit", h => shouldShowHelp = h != null }, { "electric-gripper", "rethink electric gripper is attached", n => electric_gripper = n != null }, { "vacuum-gripper", "rethink vacuum gripper is attached", n => vacuum_gripper = n != null }, { "gripper-info-file=", "gripper info file", n => gripper_info_file = n }, { "gripper-name=", "override the gripper device name", n => gripper_name = n }, { "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null } }; List <string> extra; try { // parse the command line extra = options.Parse(args); } catch (OptionException e) { // output some error message Console.Write("SawyerRobotRaconteurDriver: "); Console.WriteLine(e.Message); Console.WriteLine("Try `SawyerRobotRaconteurDriver --help' for more information."); return(1); } if (shouldShowHelp) { Console.WriteLine("Usage: SawyerRobotRaconteurDriver [Options+]"); Console.WriteLine(); Console.WriteLine("Options:"); options.WriteOptionDescriptions(Console.Out); return(0); } if (robot_info_file == null) { Console.WriteLine("error: robot-info-file must be specified"); return(1); } if (vacuum_gripper && electric_gripper) { throw new ArgumentException("--vacuum-gripper and --electric-gripper are mutually exclusive"); } Tuple <RobotInfo, LocalIdentifierLocks> robot_info = null; Tuple <ToolInfo, LocalIdentifierLocks> tool_info = null; SawyerRobot robot = null; ISawyerGripper gripper = null; try { robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file, robot_name); ros_csharp_interop.ros_csharp_interop.init_ros(args, "sawyer_robotraconteur_driver", false); if (electric_gripper || vacuum_gripper) { tool_info = ToolInfoParser.LoadToolInfoYamlWithIdentifierLocks(gripper_info_file, gripper_name); tool_info.Item1.device_info.parent_device = robot_info.Item1.device_info.device; tool_info.Item1.device_info.device_origin_pose = new NamedPose { parent_frame = new Identifier { name = "right_hand", uuid = new com.robotraconteur.uuid.UUID { uuid_bytes = new byte[16] } }, pose = new Pose { orientation = new Quaternion { w = 1 } } }; } robot = new SawyerRobot(robot_info.Item1, ""); if (electric_gripper) { gripper = new SawyerElectricGripper(tool_info.Item1, "right_gripper", ""); gripper._start_tool(); } else if (vacuum_gripper) { gripper = new SawyerVacuumGripper(tool_info.Item1, "right_vacuum_gripper", ""); gripper._start_tool(); } robot._start_robot(); using (var node_setup = new ServerNodeSetup("sawyer_robot", 58653, args)) { var robot_service_ctx = RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot); robot_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(robot_info.Item1.device_info)); if (gripper != null) { var tool_service_ctx = RobotRaconteurNode.s.RegisterService("gripper", "com.robotraconteur.robotics.tool", gripper); tool_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(tool_info.Item1.device_info)); } if (!wait_signal) { Console.WriteLine("Press enter to exit"); Console.ReadKey(); } else { UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Mono.Unix.Native.Signum.SIGINT), new UnixSignal(Mono.Unix.Native.Signum.SIGTERM), }; Console.WriteLine("Press Ctrl-C to exit"); // block until a SIGINT or SIGTERM signal is generated. int which = UnixSignal.WaitAny(signals, -1); Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum); } } } finally { robot_info?.Item2?.Dispose(); tool_info?.Item2?.Dispose(); robot?.Dispose(); gripper?.Dispose(); } return(0); }
private static Dictionary <String, PropertyDescriptor> GetPropertyDescriptors(Type type, PropertyDescriptor initializers, out object[] typeBehaviors) { var propertyMap = new Dictionary <String, PropertyDescriptor>(); var interfaceBehaviors = typeBehaviors = ExpandBehaviors(AttributesUtil.GetInterfaceAttributes(type)).ToArray(); var defaultFetch = typeBehaviors.OfType <FetchAttribute>().Select(b => (bool?)b.Fetch).FirstOrDefault().GetValueOrDefault(); #if DOTNET40 initializers.AddBehaviors(typeBehaviors.OfType <IDictionaryMetaInitializer>()) .AddBehaviors(typeBehaviors.OfType <IDictionaryInitializer>()); #else initializers.AddBehaviors(typeBehaviors.OfType <IDictionaryMetaInitializer>().Cast <IDictionaryBehavior>()) .AddBehaviors(typeBehaviors.OfType <IDictionaryInitializer> ().Cast <IDictionaryBehavior>()); #endif CollectProperties(type, property => { var propertyBehaviors = ExpandBehaviors(AttributesUtil.GetAttributes <object>(property)).ToArray(); var propertyDescriptor = new PropertyDescriptor(property, propertyBehaviors) .AddBehaviors(propertyBehaviors.OfType <IDictionaryBehavior>()) .AddBehaviors(interfaceBehaviors.OfType <IDictionaryBehavior>().Where(b => b is IDictionaryKeyBuilder == false)) #if DOTNET40 .AddBehaviors(ExpandBehaviors(AttributesUtil .GetInterfaceAttributes(property.ReflectedType)) .OfType <IDictionaryKeyBuilder>()); #else .AddBehaviors(ExpandBehaviors(AttributesUtil .GetInterfaceAttributes(property.ReflectedType)) .OfType <IDictionaryKeyBuilder>() .Cast <IDictionaryBehavior>()); #endif AddDefaultGetter(propertyDescriptor); var propertyFetch = propertyBehaviors.OfType <FetchAttribute>().Select(b => (bool?)b.Fetch).FirstOrDefault(); propertyDescriptor.IfExists = propertyBehaviors.OfType <IfExistsAttribute>().Any(); propertyDescriptor.Fetch = propertyFetch.GetValueOrDefault(defaultFetch); foreach (var descriptorInitializer in propertyDescriptor.Behaviors.OfType <IPropertyDescriptorInitializer>()) { descriptorInitializer.Initialize(propertyDescriptor, propertyBehaviors); } #if DOTNET40 initializers.AddBehaviors(propertyBehaviors.OfType <IDictionaryMetaInitializer>()); #else initializers.AddBehaviors(propertyBehaviors.OfType <IDictionaryMetaInitializer>().Cast <IDictionaryBehavior>()); #endif PropertyDescriptor existingDescriptor; if (propertyMap.TryGetValue(property.Name, out existingDescriptor)) { var existingProperty = existingDescriptor.Property; if (existingProperty.PropertyType == property.PropertyType) { if (property.CanRead && property.CanWrite) { propertyMap[property.Name] = propertyDescriptor; } return; } } propertyMap.Add(property.Name, propertyDescriptor); });
/// <inheritdoc /> public override IEnumerable <Type> BuildSerializableTypes() { //Then we want to register DTOs for unknown return(GamePacketStubMetadataMarker.GamePacketPayloadStubTypes .Where(t => GamePacketMetadataMarker.UnimplementedOperationCodes.Value.Contains(AttributesUtil.GetAttribute <GamePayloadOperationCodeAttribute>((Type)t).OperationCode)) .Concat(GamePacketMetadataMarker.SerializableTypes) .ToArray()); }
static int Main(string[] args) { bool shouldShowHelp = false; string robot_info_file = null; string robot_name = null; ushort tcp_port = 58653; string node_name = "gazebo_robot"; string model_name = null; string gazebo_url = null; var options = new OptionSet { { "robot-info-file=", n => robot_info_file = n }, { "robot-name=", "override the robot device name", n => robot_name = n }, { "model-name=", "the gazebo model to control", n => model_name = n }, { "gazebo-url=", "url for the Robot Raconteur Gazebo plugin", n => gazebo_url = n }, { "h|help", "show this message and exit", h => shouldShowHelp = h != null } }; List <string> extra; try { // parse the command line extra = options.Parse(args); } catch (OptionException e) { // output some error message Console.Write("GazeboModelRobotRaconteurDriver: "); Console.WriteLine(e.Message); Console.WriteLine("Try `GazeboModelRobotRaconteurDriver --help' for more information."); return(1); } if (shouldShowHelp) { Console.WriteLine("Usage: GazeboModelRobotRaconteurDriver [Options+]"); Console.WriteLine(); Console.WriteLine("Options:"); options.WriteOptionDescriptions(Console.Out); return(0); } if (robot_info_file == null) { Console.WriteLine("error: robot-info-file must be specified"); return(1); } if (model_name == null) { Console.WriteLine("error: model-name must be specified"); return(1); } if (gazebo_url == null) { Console.WriteLine("error: gazebo_url must be specified"); return(1); } var robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file, robot_name); robot_info.Item1.robot_capabilities &= (uint)(RobotCapabilities.jog_command | RobotCapabilities.position_command | RobotCapabilities.trajectory_command); RobotOperationalMode robot_op_mode = RobotOperationalMode.auto; var robot_class = robot_info.Item1?.device_info?.device_classes?.Find(x => x?.class_identifier?.name == "robot"); if (robot_class?.subclasses != null) { if (robot_class.subclasses.Contains("cobot")) { robot_op_mode = RobotOperationalMode.cobot; } } using (robot_info.Item2) { using (var node_setup = new ServerNodeSetup(node_name, tcp_port, args)) { using (var robot = new GazeboRobot(robot_info.Item1, gazebo_url, model_name, robot_op_mode)) { robot._start_robot(); var robot_service_ctx = RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot); robot_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(robot_info.Item1.device_info)); Console.WriteLine("Press enter to exit"); Console.ReadKey(); } } } return(0); }
private static Dictionary <String, PropertyDescriptor> GetPropertyDescriptors( Type type, out IDictionaryInitializer[] typeInitializers, out IDictionaryMetaInitializer[] metaInitializers, out object[] typeBehaviors) { var propertyMap = new Dictionary <String, PropertyDescriptor>(); var interfaceBehaviors = typeBehaviors = ExpandBehaviors(AttributesUtil.GetTypeAttributes <object>(type)).ToArray(); typeInitializers = typeBehaviors.OfType <IDictionaryInitializer>().Prioritize().ToArray(); metaInitializers = typeBehaviors.OfType <IDictionaryMetaInitializer>().Prioritize().ToArray(); var defaultFetch = typeBehaviors.OfType <FetchAttribute>().Select(b => b.Fetch).FirstOrDefault(); CollectProperties(type, property => { var propertyBehaviors = ExpandBehaviors(AttributesUtil.GetAttributes <object>(property)).ToArray(); var propertyDescriptor = new PropertyDescriptor(property, propertyBehaviors); var descriptorInitializers = propertyBehaviors.OfType <IPropertyDescriptorInitializer>(); foreach (var descriptorInitializer in descriptorInitializers.OrderBy(b => b.ExecutionOrder)) { descriptorInitializer.Initialize(propertyDescriptor, propertyBehaviors); } propertyDescriptor.AddKeyBuilders( propertyBehaviors.OfType <IDictionaryKeyBuilder>().Prioritize( ExpandBehaviors(AttributesUtil.GetTypeAttributes <object>(property.ReflectedType)).OfType <IDictionaryKeyBuilder>()) ); propertyDescriptor.AddGetters( propertyBehaviors.OfType <IDictionaryPropertyGetter>().Prioritize( interfaceBehaviors.OfType <IDictionaryPropertyGetter>()) ); AddDefaultGetter(propertyDescriptor); propertyDescriptor.AddSetters( propertyBehaviors.OfType <IDictionaryPropertySetter>().Prioritize( interfaceBehaviors.OfType <IDictionaryPropertySetter>()) ); bool?propertyFetch = (from b in propertyBehaviors.OfType <FetchAttribute>() select b.Fetch).FirstOrDefault(); propertyDescriptor.IfExists = propertyBehaviors.OfType <IfExistsAttribute>().Any(); propertyDescriptor.Fetch = propertyFetch.GetValueOrDefault(defaultFetch); PropertyDescriptor existingDescriptor; if (propertyMap.TryGetValue(property.Name, out existingDescriptor)) { var existingProperty = existingDescriptor.Property; if (existingProperty.PropertyType == property.PropertyType) { if (property.CanRead && property.CanWrite) { propertyMap[property.Name] = propertyDescriptor; } return; } } propertyMap.Add(property.Name, propertyDescriptor); }); return(propertyMap); }
static int Main(string[] args) { bool shouldShowHelp = false; string tool_info_file = null; string robot_url = null; bool wait_signal = false; var options = new OptionSet { { "tool-info-file=", n => tool_info_file = n }, { "robot-url=", "url for the robot with signals", n => robot_url = n }, { "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null }, { "h|help", "show this message and exit", h => shouldShowHelp = h != null } }; List <string> extra; try { // parse the command line extra = options.Parse(args); } catch (OptionException e) { // output some error message Console.Write("RobotSignalToolRobotRaconteurDriver: "); Console.WriteLine(e.Message); Console.WriteLine("Try `RobotSignalToolRobotRaconteurDriver --help' for more information."); return(1); } if (shouldShowHelp) { Console.WriteLine("Usage: RobotSignalToolRobotRaconteurDriver [Options+]"); Console.WriteLine(); Console.WriteLine("Options:"); options.WriteOptionDescriptions(Console.Out); Console.WriteLine("Also supports standard --robotraconteur- node options"); return(0); } if (tool_info_file == null) { Console.WriteLine("error: robot-info-file must be specified"); return(1); } if (robot_url == null) { Console.WriteLine("error: robot-url must be specified"); return(1); } Tuple <ToolInfo, LocalIdentifierLocks> tool_info = null; tool_info = ToolInfoParser.LoadToolInfoYamlWithIdentifierLocks(tool_info_file); using (tool_info.Item2) using (var node_setup = new ServerNodeSetup("robot_signal_tool", 58323, args)) { using (var tool = new UR_CB2_SoftGripper(robot_url, tool_info.Item1)) { var tool_service_ctx = RobotRaconteurNode.s.RegisterService("tool", "com.robotraconteur.robotics.tool", tool); tool_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(tool_info.Item1.device_info)); if (!wait_signal) { Console.WriteLine("Press enter to exit"); Console.ReadKey(); } else { UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Mono.Unix.Native.Signum.SIGINT), new UnixSignal(Mono.Unix.Native.Signum.SIGTERM), }; Console.WriteLine("Press Ctrl-C to exit"); // block until a SIGINT or SIGTERM signal is generated. int which = UnixSignal.WaitAny(signals, -1); Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum); } } } return(0); }