/// <summary> /// Generates the case statements for the conversion functions /// for an enumerated state variaible. /// </summary> /// <param name="consts">The string constants created.</param> /// <param name="stateVarDesc">The state variable description.</param> /// <param name="friendlyName">The code friendly name of the state variaible.</param> /// <param name="stateVarEnumValues">A StringBuilder to contain the list of enumeration values.</param> /// <param name="enumStateVarParse">A StringBuilder to contain the list of state variable parse case statements.</param> /// <param name="enumStateVarToString">A StringBuilder to contain the list of state variable to string case statements.</param> private void GenerateEnumAllowedValuesCode( StringConstants consts, StateVariableDescription stateVarDesc, string friendlyName, StringBuilder stateVarEnumValues, StringBuilder enumStateVarParse, StringBuilder enumStateVarToString) { // For each allowed value foreach (string lsAllowedValue in stateVarDesc.AllowedValues) { // Get the code friendly name string lsFriendlyValue = CodeGenProvider.CodeFriendlyIdentifier(lsAllowedValue, false); // Create the constant for the allowed value string lsAllowedValueConst = consts[ string.Format(CodeGenProvider.AllowedValueGroup, CodeGenProvider.CodeFriendlyIdentifier(stateVarDesc.Name, false)), lsAllowedValue, string.Format(CodeGenProvider.AllowedValueComment, lsAllowedValue, stateVarDesc.Name) ]; // Generate the enumeration values stateVarEnumValues.Append(string.Format(CodeGenProvider.EnumStateVarValue, lsFriendlyValue, friendlyName)); // Generate the parse case statement enumStateVarParse.Append(string.Format(CodeGenProvider.EnumParseCaseStatement, lsAllowedValueConst, friendlyName, lsFriendlyValue)); // Generate the to string case statment enumStateVarToString.Append(string.Format(CodeGenProvider.EnumToStringCaseStatement, friendlyName, lsFriendlyValue, lsAllowedValueConst)); } }
/// <summary> /// Generates the code for all state variables. /// </summary> /// <param name="service">The service containing the state variables.</param> /// <param name="testStateVars"> /// True to test each state variable to ensure it is /// usuable for accessing as property, false to include /// all state variables as properties.</param> /// <param name="consts">The string constants created.</param> /// <param name="stateVarProps">A StringBuilder to contain property definitions.</param> /// <param name="stateVarConversion">A StringBuilder to contain the conversion method definitions.</param> /// <param name="stateVarEnums">A StringBuilder to contain the enumerations for the state variables.</param> /// <param name="eventHandlers">A StringBuilder to contain event handler declarations for the state variable changes.</param> /// <param name="eventCallers">A StringBuilder to contain event caller methods for the state variable changes.</param> /// <param name="stateVarEventIntercept">A StringBuilder to contain case statement code for each event state variable.</param> /// <param name="enumStateVars">A HashSet containing the names of all enumerated state variables.</param> /// <param name="stateVarTypes">A Dictionary to contain each state variaible name and its code data type.</param> /// <param name="desc">The service description to create the state variable code from.</param> private void GenerateStateVarCode( Service service, bool testStateVars, StringConstants consts, StringBuilder stateVarProps, StringBuilder stateVarConversion, StringBuilder stateVarEnums, StringBuilder eventHandlers, StringBuilder eventCallers, StringBuilder stateVarEventIntercept, HashSet <string> enumStateVars, Dictionary <string, string> stateVarTypes, ServiceDescription desc) { // For each state variaible description foreach (StateVariableDescription lsdStateVarDesc in desc.StateVariables.Values) { string lsFriendlyName = CodeGenProvider.CodeFriendlyIdentifier(lsdStateVarDesc.Name, false); // Determine if we actually want the property accessor for the state variable bool lbAddProp = IsStateVarQueryable(service, testStateVars, lsdStateVarDesc); // If the state variable is a string and has an allowed value list if (lsdStateVarDesc.DataTypeValue == StateVariableDataType.tstring && lsdStateVarDesc.AllowedValues.Count > 0) { // Generate it using an enumeration GenerateEnumStateVarCode( consts, stateVarProps, stateVarConversion, stateVarEnums, eventHandlers, eventCallers, stateVarEventIntercept, enumStateVars, stateVarTypes, lsdStateVarDesc, lsFriendlyName, lbAddProp); } else { // Otherwise generate it using simple properties GenerateStateVarCode( consts, stateVarProps, eventHandlers, eventCallers, stateVarEventIntercept, stateVarTypes, lsdStateVarDesc, lsFriendlyName, lbAddProp); } } }
/// <summary> /// Makes a constant name based on group and value. /// </summary> /// <param name="group">The group for the constant.</param> /// <param name="name">The value for the constant.</param> /// <returns>The name of the constant.</returns> protected string MakeConstantName(string group, string name) { return (string.Format( CodeGenProvider.ConstantIdentifyer, CodeGenProvider.CodeFriendlyIdentifier(group, false, true), CodeGenProvider.CodeFriendlyIdentifier(name, false))); }
/// <summary> /// Generates the class code for a service. /// </summary> /// <param name="service">The service to generate for.</param> /// <param name="className">The class name of the service or null to use the service type.</param> /// <param name="namespaceName">The namespace for the class.</param> /// <param name="classScope">The scope for the class.</param> /// <param name="partial">True to make the class partial, false otherwise.</param> /// <param name="testStateVars"> /// True to test each state variable to ensure it is /// usuable for accessing as property, false to include /// all state variables as properties.</param> /// <returns>The string representing the code for the class.</returns> public string GenerateClassFor( Service service, string className, string namespaceName, ClassScope classScope, bool partial, bool testStateVars) { // If classname is not specified then default to service information if (className == null) { className = DefaultCodeGenClassName(service, CodeGenProvider); } else { // Otherwise ensure classname is Identifier compatible className = CodeGenProvider.CodeFriendlyIdentifier(className, false); } StringBuilder lsbStateVarProps = new StringBuilder(); StringBuilder lsbStateVarConversion = new StringBuilder(); StringBuilder lsbStateVarEnums = new StringBuilder(); StringBuilder lsbActionMethods = new StringBuilder(); StringBuilder lsbEventHandlers = new StringBuilder(); StringBuilder lsbEventCallers = new StringBuilder(); StringBuilder lsbStateVarEventIntercept = new StringBuilder(); HashSet <string> lhsEnumStateVars = new HashSet <string>(); StringConstants lscConsts = new StringConstants(CodeGenProvider); Dictionary <string, string> ldStateVarTypes = new Dictionary <string, string>(); // Get the service description ServiceDescription lsdDesc = service.Description(); if (lsdDesc != null) { // Generate the state variable property declarations GenerateStateVarCode( service, testStateVars, lscConsts, lsbStateVarProps, lsbStateVarConversion, lsbStateVarEnums, lsbEventHandlers, lsbEventCallers, lsbStateVarEventIntercept, lhsEnumStateVars, ldStateVarTypes, lsdDesc); // Generate the action methods GenerateActionCode( lscConsts, lsbActionMethods, lhsEnumStateVars, ldStateVarTypes, lsdDesc); } if (lsbStateVarEventIntercept.Length > 0) { lsbEventCallers.Append( String.Format(CodeGenProvider.StateVarChangedEventHandler, lsbStateVarEventIntercept) ); } return (String.Format( CodeGenProvider.ServiceBase, namespaceName, className, service.ServiceTypeIdentifier, CodeGenProvider.GenerateRegion(CodeGenProvider.PublicEnumerations, lsbStateVarEnums.ToString()), (partial ? CodeGenProvider.PartialClass : String.Empty), CodeGenProvider.GenerateRegion(CodeGenProvider.ProtectedMethods, lsbStateVarConversion.ToString()), lsbActionMethods, CodeGenProvider.GenerateRegion(CodeGenProvider.PublicProperties, lsbStateVarProps.ToString()), CodeGenProvider.GenerateRegion(CodeGenProvider.ProtectedConstants, lscConsts.Definitions().ToString(), false, false), CodeGenProvider.GetClassScope(classScope, CodeGenProvider.Space.ToString()), CodeGenProvider.GenerateRegion(CodeGenProvider.EventHandlers, lsbEventHandlers.ToString(), true), CodeGenProvider.GenerateRegion(CodeGenProvider.EventCallers, lsbEventCallers.ToString()), string.Format( CodeGenProvider.ServiceClassHeaderComment, (service.Device != null && service.Device.RootDevice != null ? service.Device.RootDevice.FriendlyName : CodeGenProvider.Null), (service.Device != null && service.Device.RootDevice != null ? service.Device.RootDevice.Type : CodeGenProvider.Null), (service.Device != null && service.Device.RootDevice != null ? service.Device.RootDevice.SerialNumber : CodeGenProvider.Null), (service.Device != null ? service.Device.FriendlyName : CodeGenProvider.Null), (service.Device != null ? service.Device.Type : CodeGenProvider.Null), service.Id, service.ServiceTypeIdentifier, DateTime.Now.ToString(), className, namespaceName, classScope.ToString(), (partial ? CodeGenProvider.PartialClass : string.Empty), testStateVars, CodeGenProvider.ToString() ) )); }
/// <summary> /// Generates the code for all actions. /// </summary> /// <param name="consts">The stirng constants created.</param> /// <param name="actionMethods">The StringBuilder to contain the action call methods.</param> /// <param name="enumStateVars">A HashSet of the state variables which are enumerations.</param> /// <param name="stateVarTypes">A Dictionary containing the state variables and their data types.</param> /// <param name="desc">The service description to generate the action code for.</param> private void GenerateActionCode( StringConstants consts, StringBuilder actionMethods, HashSet <string> enumStateVars, Dictionary <string, string> stateVarTypes, ServiceDescription desc) { // For each action foreach (ActionDescription ladDesc in desc.Actions.Values) { string lsFriendlyName = CodeGenProvider.CodeFriendlyIdentifier(ladDesc.Name, false); int liInArgumentCount = 0; int liInArgumentIndex = 0; int liOutArgumentIndex = 0; StringBuilder lsbInArguments = new StringBuilder(); StringBuilder lsbOutArguments = new StringBuilder(); StringBuilder lsbInSetValues = new StringBuilder(); StringBuilder lsbOutSetValues = new StringBuilder(); StringBuilder lsbInParamComments = new StringBuilder(); StringBuilder lsbOutParamComments = new StringBuilder(); StringBuilder lsbReturnsComments = new StringBuilder(); int liOutArguments = ladDesc.Arguments.OutArgCount; string lsLastOutType = CodeGenProvider.UnknownType; // For each argument foreach (ArgumentDescription ladArgDesc in ladDesc.Arguments.Values) { bool lbEnumStateVar = enumStateVars.Contains(ladArgDesc.RelatedStateVariable); string lsArgFriendlyName = CodeGenProvider.CodeFriendlyIdentifier(ladArgDesc.Name, true); string lsRelatedStateVarFriendlyName = CodeGenProvider.CodeFriendlyIdentifier(ladArgDesc.RelatedStateVariable, false); string lsType; // Get the type of the related state variable, or use unknown type if state variable cannot be found if (!stateVarTypes.TryGetValue(ladArgDesc.RelatedStateVariable, out lsType)) { lsType = CodeGenProvider.UnknownType; } // Determine direction if (ladArgDesc.DirectionValue == ArgumentDirection.Out) { lsLastOutType = lsType; // If there is more than 1 out argument then use out parameters if (liOutArguments > 1) { GenerateOutArgumentCode( ladArgDesc, liOutArgumentIndex, lsbOutArguments, lsbOutSetValues, lbEnumStateVar, lsArgFriendlyName, lsRelatedStateVarFriendlyName, lsType, lsbOutParamComments); } else { // Otherwise use a returning function GenerateOutArgumentReturnCode( ladArgDesc, liOutArgumentIndex, lsbOutSetValues, lbEnumStateVar, lsRelatedStateVarFriendlyName, lsType, lsbReturnsComments); } // Increment the out argument index liOutArgumentIndex++; } else { // Generate the in argument code GenerateInArgumentCode( ladArgDesc, liInArgumentIndex, lsbInArguments, lsbInSetValues, lbEnumStateVar, lsArgFriendlyName, lsRelatedStateVarFriendlyName, lsType, lsbInParamComments); // Increment in argument count and index liInArgumentCount++; liInArgumentIndex++; } } // Generate the method code actionMethods.Append( string.Format( (liOutArguments == 1 ? CodeGenProvider.ReturnAction : CodeGenProvider.Action), lsFriendlyName, lsbInArguments, lsbOutArguments, CodeGenProvider.ArraySizeForCount(liInArgumentCount), lsbInSetValues, consts[CodeGenProvider.ActionNameGroup, ladDesc.Name, string.Format(CodeGenProvider.ActionNameComment, ladDesc.Name)], lsbOutSetValues, (lsbInArguments.Length > 0 && lsbOutArguments.Length > 0 ? CodeGenProvider.ParameterSeperator : String.Empty), lsLastOutType, lsbInParamComments, lsbOutParamComments, lsbReturnsComments, (liOutArguments > 0 ? CodeGenProvider.OutVar : string.Empty) ) ); } }
/// <summary> /// Gets the file names for the device and service classes. /// </summary> /// <param name="services">The ClassName, Service dictionary identifying the services.</param> /// <param name="devices">The ClassName, Device dictionary identifying the devices.</param> /// <returns>A dictionary containing Serve/Device, FileNames.</returns> private Dictionary <object, string> GetFileNames( Dictionary <string, Service> services, Dictionary <string, Device> devices) { Dictionary <object, string> ldRet = new Dictionary <object, string>(); // Get the file extension string lsFileExt; if (cbPartialClasses.Checked) { lsFileExt = CodeGenProvider.PartialClassFileExtension; } else { lsFileExt = CodeGenProvider.ClassFileExtension; } // For each device foreach (KeyValuePair <string, Device> lkvValue in devices) { // Generate the file name string lsFileName = Path.ChangeExtension(Path.Combine( tbDeviceDestinationFolder.Text, CodeGenProvider.CodeFriendlyIdentifier(lkvValue.Key, false)), lsFileExt); // If its a duplicate then tell the user if (ldRet.ContainsKey(lsFileName)) { throw new Exception( string.Format( "The classname filename for Device '{0}' of '{1}' is a duplicate.\r\nPlease revise the class names.", lkvValue.Key, lsFileName)); } // Set the filename ldRet[lkvValue.Value] = lsFileName; } // For each service foreach (KeyValuePair <string, Service> lkvValue in services) { // Generate the file name string lsFileName = Path.ChangeExtension(Path.Combine( tbServiceDestinationFolder.Text, CodeGenProvider.CodeFriendlyIdentifier(lkvValue.Key, false)), lsFileExt); // If its a duplicate then tell the user if (ldRet.ContainsKey(lsFileName)) { throw new Exception( string.Format( "The classname filename for Service '{0}' or '{1}' is a duplicate.\r\nPlease revise the class names.", lkvValue.Key, lsFileName)); } // Set the file name ldRet[lkvValue.Value] = lsFileName; } // Return the file names return(ldRet); }
/// <summary> /// Generates the class code for a device. /// </summary> /// <param name="device">The device to generate code for.</param> /// <param name="className">The class name of the device class or null to use friendly name.</param> /// <param name="namespaceName">The namespace for the class.</param> /// <param name="classScope">The scope of the class.</param> /// <param name="partial">True to make the class partial, false otherwise.</param> /// <param name="specificDevices">True if generating properties for device specific class types, false to use device non-specific class types.</param> /// <param name="specificServiceNamespace">The name of the service namespace if using specific service class types, null to use service non-specific class types.</param> /// <param name="specificDeviceClasses">The dictionary of UDNs, ClassNames for the devices or null for default / none.</param> /// <param name="specificServiceClasses">The dictionary of IDs, ClassNames for the services or null for default / none.</param> /// <returns>The string representing the code for the class.</returns> public string GenerateClassFor( Device device, string className, string namespaceName, ClassScope classScope, bool partial, bool specificDevices, string specificServiceNamespace, Dictionary <string, string> specificDeviceClasses = null, Dictionary <string, string> specificServiceClasses = null) { if (className == null) { className = DefaultCodeGenClassName(device, CodeGenProvider); } else { className = CodeGenProvider.CodeFriendlyIdentifier(className, false); } // No namespace specified then set it not use one if (string.IsNullOrEmpty(specificServiceNamespace)) { specificServiceNamespace = string.Empty; } // Set the specific services bool mbSpecificServices = specificServiceNamespace.Length > 0; string lsUsing; // If service namespace is different to device namespace if (specificServiceNamespace != namespaceName) { // Add the services namespace to the using clause lsUsing = (mbSpecificServices ? string.Format(CodeGenProvider.UsingClause, specificServiceNamespace) : string.Empty); } else { // Otherwise dont add anything to the uses clause lsUsing = string.Empty; } StringConstants lscConstants = new StringConstants(CodeGenProvider); StringBuilder lsbProperties = new StringBuilder(); // Build the child devices properties GenerateDevicePropertyCode(device, specificDevices, lscConstants, lsbProperties, specificDeviceClasses); // Build the child services properties GenerateServicePropertyCode(device, mbSpecificServices, lscConstants, lsbProperties, specificServiceClasses); // Build the code for the device class return (string.Format( CodeGenProvider.DeviceBase, lsUsing, namespaceName, CodeGenProvider.GetClassScope(classScope, CodeGenProvider.Space.ToString()), (partial ? CodeGenProvider.PartialClass : string.Empty), className, CodeGenProvider.GenerateRegion(CodeGenProvider.ProtectedConstants, lscConstants.Definitions().ToString(), false, false), device.Type, CodeGenProvider.GenerateRegion(CodeGenProvider.PublicProperties, lsbProperties.ToString()), device.ModelName, string.Format( CodeGenProvider.DeviceClassHeaderComment, (device.RootDevice != null ? device.RootDevice.FriendlyName : CodeGenProvider.Null), (device.RootDevice != null ? device.RootDevice.Type : CodeGenProvider.Null), (device.RootDevice != null ? device.RootDevice.SerialNumber : CodeGenProvider.Null), device.FriendlyName, device.Type, DateTime.Now.ToString(), className, namespaceName, classScope.ToString(), (partial ? CodeGenProvider.PartialClass : string.Empty), CodeGenProvider.ToString() ) )); }