public void ProducerFunc()
{
	int data = 0;

	for (int i = 0; i < 10000; i++)
	{
		data += 1;
		MessageHandler(data);
		Thread.Sleep(m_Random.Next(0, 2));
	}
}

private void MessageHandler(int data)
{
	m_UnblockHandlerEvent.WaitOne();
	m_HandlerFinishedEvent.Reset();

	m_CurrentWriteQueue.Enqueue(data);
	m_ProducerData.WriteLine(data); // logging

	m_DataAvailableEvent.Set();
	m_HandlerFinishedEvent.Set();
}

public void ConsumerFunc()
{
	int count;
	int data;
	Queue<int> readQueue;

	while (true)
	{
		m_DataAvailableEvent.WaitOne();

		m_UnblockHandlerEvent.Reset(); // block the producer
		m_HandlerFinishedEvent.WaitOne(); // wait for the producer to finish
		readQueue = m_CurrentWriteQueue;
		// switch the write queue
		m_CurrentWriteQueue = (m_CurrentWriteQueue == m_Q1) ? m_Q2 : m_Q1;
		m_UnblockHandlerEvent.Set(); // unblock the producer

		count = ;
		while (readQueue.Count > )
		{
			count += 1;

			data = readQueue.Dequeue();
			m_ConsumerData.WriteLine(data); // logging

			Thread.Sleep(m_Random.Next(0, 2));
		}
		Console.WriteLine("Removed {0} items from queue: {1}",
					count, readQueue.GetHashCode());
	}
}

• Writing a workflow condition
  
• Writing a workflow validator
  
• Writing a workflow post function
  
• Editing an active workflow
  

A JIRA workflow is the set of steps and transitions an issue goes through during its lifecycle. Workflows typically represent business processes.

• An issue can exist in only one step at any point in time
  
• A status can be mapped to only one step in the workflow
  
• A transition is always one-way. So if you need to go back to the previous step, you need a different transition
  
• A transition can optionally specify a screen to be presented to the user with the right fields on it
  

• Conditions: A set of conditions that need to be satisfied before the user can actually see the workflow action (transition) on the issue
  
• Validators: A set of validators which can be used to validate the user input before moving to the destination step
  
• Post Functions: A set of actions which will be performed after the issue is successfully moved to the destination step
  

• Define the inputs needed to configure the workflow condition.
  We need to implement the WorkflowPluginFactory interface, which mainly exists to provide velocity parameters to the templates. It will be used to extract the input parameters that are used in defining the condition. To make it clear, the inputs here are not the inputs while performing the workflow action, but the inputs in defining the condition.
  The condition factory class, RoleConditionFactory in this case, extends the AbstractWorkflowPluginFactory, which implements the WorkflowPluginFactory interface. There are three abstract methods that we should implement, that is, getVelocityParamsForInput, getVelocityParamsForEdit, and getVelocityParamsForView. All of them, as the name suggests, are used for populating the velocity parameters for the different scenarios.
  In our example, we need to limit the workflow action to a certain project role, and so we need to select the project role while defining the condition. The three methods will be implemented as follows:
  

  	
  		private static final String ROLE_NAME = "role";
  			private static final String ROLES = "roles";
  			.......
  			@Override
  			  protected void getVelocityParamsForEdit(Map
  			velocityParams, AbstractDescriptor descriptor) {
  				velocityParams.put(ROLE, getRole(descriptor));
  				velocityParams.put(ROLES, getProjectRoles());
  			  }  @Override
  			  protected void getVelocityParamsForInput(Map
  			velocityParams) {
  				velocityParams.put(ROLES, getProjectRoles());
  			  }  @Override
  			  protected void getVelocityParamsForView(Map
  			velocityParams, AbstractDescriptor descriptor) {
  				velocityParams.put(ROLE, getRole(descriptor));
  			  }	
  			
  

  
  
  Let's look at the methods in detail:
  
  
  
  • getVelocityParamsForInput: This method defines the velocity parameters for input scenario, that is, when the user initially configures the workflow. In our example, we need to display all the project roles so that the user can select one to define the condition. The method getProjectRoles merely returns all the project roles and the collection of roles is then put into the velocity parameters with the key ROLES.
    
  • getVelocityParamsForView: This method defines the velocity parameters for the view scenario, that is, how the user sees the condition after it is configured. In our example, we have defined a role and so we should display it to the user after retrieving it back from the workflow descriptor. If you have noticed, the descriptor, which is an instance of AbstractDescriptor, is available as an argument in the method. All we need is to extract the role from the descriptor, which can be done as follows:
    

    	
    		private ProjectRole getRole(AbstractDescriptor descriptor){
    				if (!(descriptor instanceof ConditionDescriptor)) {
    				  throw new IllegalArgumentException("Descriptor must be a
    			ConditionDescriptor.");
    				}
    				
    			  ConditionDescriptor functionDescriptor = (ConditionDescriptor)
    			descriptor;
    				
    			 String role = (String) functionDescriptor.getArgs().get(ROLE);
    				if (role!=null && role.trim().length()>0)
    				  return getProjectRole(role);
    				else
    				  return null;
    			  }	
    			
    

    
    
    Just check if the descriptor is a condition descriptor or not, and then extract the role as shown in the preceding snippet.
    
  • getVelocityParamsForEdit: This method defines the velocity parameters for the edit scenario, that is, when the user modifies the existing condition. Here we need both the options and the selected value. Hence, we put both the project roles collection and the selected role on to the velocity parameters.
    
  
  

• The second step is to define the velocity templates for each of the three aforementioned scenarios: input, view, and edit. We can use the same template here for input and edit with a simple check to keep the old role selected for the edit scenario. Let us look at the templates:
  
  
  
  • edit-roleCondition.vm: Displays all project roles and highlights the already-selected one in the edit mode. In the input mode, the same template is reused, but the selected role will be null and hence a null check is done:
    

    	
    	
    	
    		
    		
    			
    			#foreach ($field in $roles)
    						  #if ($role && (${field.id}==${role.id}))
    					SELECTED
    				#end
    				>$field.name
    			#end
    			
    			
    	Select the role in which the user
    	should be present!
    		
    	
    	
    	
    

    
    
  • view-roleCondition.vm: Displays the selected role:
    

  	
  #if ($role)
  	  User should have ${role.name} Role!
  	#else
  	  Role Not Defined
  	#end	
  	
  

  
  
  
• The third step is to write the actual condition. The condition class should extend the AbstractJiraCondition class. Here we need to implement the passesCondition method. In our case, we retrieve the project from the issue, check if the user has the appropriate project role, and return true if the user does:
  

  	
  public boolean passesCondition(Map transientVars, Map args,
  	PropertySet ps) throws WorkflowException {
  		Issue issue = getIssue(transientVars);
  		User user = getCaller(transientVars, args);	project project = issue.getProjectObject();
  		String role = (String)args.get(ROLE);
  		Long roleId = new Long(role);	return projectRoleManager.isUserInProjectRole(user,
  	projectRoleManager.getProjectRole(roleId), project);
  	}	
  	
  

  
  
  The issue on which the condition is checked can be retrieved using the getIssue method implemented in the AbstractJiraCondition class. Similarly, the user can be retrieved using the getCaller method. In the preceding method, projectRoleManager is injected in the constructor, as we have seen before.
  
• We can see that the ROLE key is used to retrieve the project role ID from the args parameter in the passesCondition method. In order for the ROLE key to be available in the args map, we need to override the getDescriptorParams method in the condition factory class, RoleConditionFactory in this case. The getDescriptorParams method returns a map of sanitized parameters, which will be passed into workflow plugin instances from the values in an array form submitted by velocity, given a set of name:value parameters from the plugin configuration page (that is, the 'input-parameters' velocity template). In our case, the method is overridden as follows:
  

  	
  public Map getDescriptorParams(Map
  	conditionParams) {
  		if (conditionParams != null &&
  	conditionParams.containsKey(ROLE))
  			{
  				return EasyMap.build(ROLE,
  	extractSingleParam(conditionParams, ROLE));
  			}
  			// Create a 'hard coded' parameter
  			return EasyMap.build();
  	  }	
  	
  

  
  
  The method here builds a map of the key:value pair, where key is ROLE and the value is the role value entered in the input configuration page. The extractSingleParam method is implemented in the AbstractWorkflowPluginFactory class. The extractMultipleParams method can be used if there is more than one parameter to be extracted!
  
• All that is left now is to populate the atlassian-plugin.xml file with the aforementioned components. We use the workflow-condition module and it looks like the following block of code:
  
  
  
• Package the plugin and deploy it!
  How it works...
  After the plugin is deployed, we need to modify the workflow to include the condition. The following screenshot is how the condition looks when it is added initially. This, as you now know, is rendered using the input template:
  

/sites/default/files/Article-Images/1803-04-02.png

(Move the mouse over the image to enlarge.)

See http://confluence.at...ules-Validators for more details.

• Define the inputs needed to configure the workflow validator:
  We need to implement the WorkflowPluginValidatorFactory interface, which mainly exists to provide velocity parameters to the templates. It will be used to extract the input parameters that are used in defining the validator. To make it clear, the inputs here are not the input while performing the workflow action, but the inputs in defining the validator.
  The validator factory class, FieldValidatorFactory in this case, extends the AbstractWorkflowPluginFactory interface and implements the WorkflowPluginValidatorFactory interface. Just like conditions, there are three abstract methods that we should implement. They are getVelocityParamsForInput, getVelocityParamsForEdit, and getVelocityParamsForView. All of them, as the names suggest, are used for populating the velocity parameters in different scenarios.
  In our example, we have a single input field, which is the name of a custom field. The three methods will be implemented as follows:
  

  	
  		@Override
  			protected void getVelocityParamsForEdit(Map velocityParams,
  			AbstractDescriptor descriptor) {
  				velocityParams.put(FIELD_NAME, getFieldName(descriptor));
  			  velocityParams.put(FIELDS, getCFFields());
  			}@Override
  			protected void getVelocityParamsForInput(Map velocityParams) {
  				velocityParams.put(FIELDS, getCFFields());
  			}@Override
  			protected void getVelocityParamsForView(Map velocityParams,
  			AbstractDescriptor descriptor) {
  				velocityParams.put(FIELD_NAME, getFieldName(descriptor));
  			}	
  			
  

  
  
  You may have noticed that the methods look quite similar to the ones in a workflow condition, except for the business logic! Let us look at the methods in detail:
  
  
  
  • getVelocityParamsForInput: This method defines the velocity parameters for input scenario, that is, when the user initially configures the workflow. In our example, we need to display all the custom fields, so that the user can select one to use in the validator. The method getCFFields returns all the custom fields and the collection of fields is then put into the velocity parameters with the key fields.
    
  • getVelocityParamsForView: This method defines the velocity parameters for the view scenario, that is, how the user sees the validator after it is configured. In our example, we have defined a field and so we should display it to the user after retrieving it back from the workflow descriptor. You may have noticed that the descriptor, which is an instance of AbstractDescriptor, is available as an argument in the method. All we need is to extract the field name from the descriptor, which can be done as follows:
    

    	
    		private String getFieldName(AbstractDescriptor descriptor){
    			  if (!(descriptor instanceof ValidatorDescriptor)) {
    				throw new IllegalArgumentException('Descriptor must be a
    			ValidatorDescriptor.');
    			  }
    			  
    			  ValidatorDescriptor validatorDescriptor = (ValidatorDescriptor)
    			descriptor;  String field = (String)
    			validatorDescriptor.getArgs().get(FIELD_NAME);
    			  if (field != null && field.trim().length() > 0)
    				return field;
    			  else
    				return NOT_DEFINED;
    			}	
    			
    

    
    
    Just check if the descriptor is a validator descriptor or not and then extract the field as shown in the preceding snippet.
    
  • getVelocityParamsForEdit: This method defines the velocity parameters for the edit scenario, that is, when the user modifies the existing validator. Here we need both the options and the selected value. Hence we put both the custom fields' collection and the field name onto the velocity parameters.
    
  
  

• The second step is to define the velocity templates for each of the three aforementioned scenarios, namely, input, view, and edit. We can use the same template here for input and edit with a simple checking to keep the old field selected for the edit scenario. Let us look at the template:
  
  
  
  • edit-fieldValidator.vm: Displays all custom fields and highlights the already selected one in edit mode. In input mode, the field variable will be null, and so nothing is pre-selected:
    

    	
    	
    	
    	  
    	  
    		
    		#foreach ($cf in $fields)
    				  #if ($cf.name.equals($field)) SELECTED #end
    		  >$cf.name
    		#end
    		
    		
    	Select the Custom Field to be validated
    	for NULL
    	  
    	
    	
    	
    

    
    
  • view-fieldValidator.vm: Displays the selected field:
    

    	
    #if ($field)
    	  Field '$field' is Required!
    	#end	
    	
    

    
    
• The third step is to write the actual validator. The validator class should implement the Validator interface. All we need here is to implement the validate method. In our example, we retrieve the custom field value from the issue and throw an InvalidInputException if the value is null (empty):
  

  	
  public void validate(Map transientVars, Map args, PropertySet ps)
  	throws InvalidInputException, WorkflowException {
  		Issue issue = (Issue) transientVars.get("issue");
  		String field = (String) args.get(FIELD_NAME);	  CustomField customField =
  	customFieldManager.getCustomFieldObjectByName(field);	if (customField!=null){
  		  //Check if the custom field value is NULL
  		  if (issue.getCustomFieldValue(customField) == null){
  			throw new InvalidInputException("The field:"+field+" is
  				 required!"); }
  		}
  	  }	
  	
  

  
  
  The issue on which the validation is done can be retrieved from the transientVars map. customFieldManager is injected in the constructor as usual.
  
• All that is left now is to populate the atlassian-plugin.xml file with these components. We use the workflow-validator module, and it looks like the following block of code:
  

  	
  class="com.jtricks.FieldValidatorFactory">
  		Field Not Empty Workflow Validator	com.jtricks.FieldValidator	location="templates/com/jtricks/view-fieldValidator.vm"/>
  		location="templates/com/jtricks/edit-fieldValidator.vm"/>
  		location="templates/com/jtricks/edit-fieldValidator.vm"/>	
  	
  

  
  
• Package the plugin and deploy it!
  Note that we have stored the role name instead of the ID in the workflow, unlike what we did in the workflow condition. However, it is safe to use the ID because administrators can rename the roles, which would then need changes in the workflows.
  
  How it works...
  After the plugin is deployed, we need to modify the workflow to include the validator. The following screenshot is how the validator looks when it is added initially. This, as you now know, is rendered using the input template:
  

• orderable – (true/false) Specifies if this function can be re-ordered within the list of functions associated with a transition. The position within the list determines when the function actually executes.
  
• unique – (true/false) Specifies if this function is unique, that is, if it is possible to add multiple instances of this post function on a single transition.
  
• deletable – (true/false) Specifies if this function can be removed from a transition.
  

See http://confluence.at...dules-Functions for more details.

• Define the inputs needed to configure the workflow post function:
  As opposed to workflow conditions and validators, there are two interfaces available for a workflow post function factory class. If there are no inputs needed to configure the function, the factory class must implement WorkflowNoInputPluginFactory.
  An example will be to set the current user's name as the custom field value instead of the user configured name. If inputs are needed to configure the post function, the factory class must implement WorkflowPluginFunctionFactory. In our example, we take the username as the input.
  Both the interfaces mainly exist to provide velocity parameters to the templates. They will be used to extract the input parameters that are used in defining the functions. To make it clear, the inputs here are not the input while performing the workflow action, but the inputs in defining the post function.
  The function factory class, SetUserCFFunctionFactory in this case, extends the AbstractWorkflowPluginFactory and implements the WorkflowPluginFunctionFactory interface. Just like conditions, there are three abstract methods that we should implement, namely, getVelocityParamsForInput, getVelocityParamsForEdit, and getVelocityParamsForView. All of them, as the names suggest, are used for populating the velocity parameters for the different scenarios:
  

  	
  		@Override
  			protected void getVelocityParamsForEdit(Map velocityParams,
  			AbstractDescriptor descriptor) {
  				velocityParams.put(USER_NAME, getUserName(descriptor));
  			}@Override
  			protected void getVelocityParamsForInput(Map velocityParams) {
  				velocityParams.put(USER_NAME, CURRENT_USER); }@Override
  			protected void getVelocityParamsForView(Map velocityParams,
  			AbstractDescriptor descriptor) {
  				velocityParams.put(USER_NAME, getUserName(descriptor));
  			}	
  			
  

  
  
  You may have noticed that the methods look very similar to the ones in workflow conditions or validators, except for the business logic! Let us look at the methods in detail:
  
  
  
  • getVelocityParamsForInput : This method defines the velocity parameters for input scenario, that is, when the user initially configures the workflow. In our example, we need to use a text field that captures the username to be added on the issue.
    
  • getVelocityParamsForView: This method defines the velocity parameters for the view scenario, that is, how the user sees the post function after it is configured. In our example, we have defined a field, and so we should display it to the user after retrieving it from the workflow descriptor. You may have noticed that the descriptor, which is an instance of AbstractDescriptor, is available as an argument in the method. All we need is to extract the username from the descriptor, which can be done as follows:
    

    	
    		private String getUserName(AbstractDescriptor descriptor){
    				if (!(descriptor instanceof FunctionDescriptor)) {
    				  throw new IllegalArgumentException("Descriptor must be a
    			 FunctionDescriptor.");
    				}	FunctionDescriptor functionDescriptor =
    			(FunctionDescriptor) descriptor;
    			 String user = (String)
    			functionDescriptor.getArgs().get(USER_NAME);
    				if (user!=null && user.trim().length()>0)
    				  return user;
    				else
    				  return CURRENT_USER;
    			  }	
    			
    

    
    
    Just check if the descriptor is a validator descriptor or not, and then extract the field as shown in the preceding snippet.
    
  • getVelocityParamsForEdit: This method defines the velocity parameters for the edit scenario, that is, when the user modifies the existing validator. Here we need both the options and the selected value. Hence, we put both the custom fields' collection and the field name on to the velocity parameters.
    
  
  

• The second step is to define the velocity templates for each of the three scenarios: input, view, and edit. We can use the same template here for input and edit with a simple checking to keep the old field selected for the edit scenario. Let us look at the templates:
  
  
  
  • edit-userCFFunction.vm: Displays all custom fields and highlights the already selected one in the edit mode:
    
    
    
  • view-userCFFunction.vm .displays the selected field:
    

    	
    #if ($user)
    	  The 'Test User' CF will be set with value : $user!
    	#end	
    	
    

    
    
• The third step is to write the actual function. The function class must extend the AbstractJiraFunctionProvider interface. All we need here is to implement the execute method. In our example, we retrieve the username from the issue and set it on the Test User custom field:
  

  	
  public void execute(Map transientVars, Map args, PropertySet ps)
  	throws WorkflowException {
  		MutableIssue issue = getIssue(transientVars);
  		User user = null;	if (args.get("user") != null) {
  		  String userName = (String) args.get("user");
  		  if (userName.equals("Current User")){
  			// Set the current user here!
  			user = authContext.getUser();
  		  } else {
  			user = userUtil.getUser(userName);
  		  }
  		} else {
  		  // Set the current user here!
  		  user = authContext.getUser();
  		}
  		// Now set the user value to the custom field
  		CustomField userField =
  	customFieldManager.getCustomFieldObjectByName("Test User");
  		if (userField != null) {
  		  try {
  			setUserValue(issue, user, userField);
  		  } catch (FieldLayoutStorageException e) {
  			System.out.println("Error while setting the user Field");
  		  }
  		}
  	 }	
  	
  

  
  
  Like a validator, the issue on which the post function is executed can be retrieved using the transientVars map. The user can be retrieved from the args map.
  Here the setUserValue method simply sets the username on the passed custom field, as shown in the following block of code:
  

  	
  private void setUserValue(MutableIssue issue, User user,
  	CustomField userField) throws FieldLayoutStorageException {
  		issue.setCustomFieldValue(userField, user);
  		Map modifiedFields = issue.getModifiedFields();
  		FieldLayoutItem fieldLayoutItem =
  	ComponentManager.getInstance().getFieldLayoutManager().getFieldLay
  	out(issue).getFieldLayoutItem(userField);
  		DefaultIssueChangeHolder issueChangeHolder = new
  	DefaultIssueChangeHolder();
  		final ModifiedValue modifiedValue = (ModifiedValue)
  	modifiedFields.get(userField.getId());	
  	userField.updateValue(fieldLayoutItem, issue, modifiedValue,
  	issueChangeHolder);
  	  }	
  	
  

  
  
• All that is left now is to populate the atlassian-plugin.xml file with these components. We use the workflow-condition module and it looks like the following block of code:
  
  
  
• Package the plugin and deploy it!
  How it works...
  After the plugin is deployed, we need to modify the workflow to include the function. The following is where the function appears along with the built-in ones:
  

/sites/default/files/Article-Images/1803-04-08.png

• Login as a JIRA Administrator.
  
• Navigate to Administration Global Settings | Workflows|.
  
• Click on the Create a draft workflow link on the workflow you want to edit. The link can be found under the Operations column.
  
• Click on the step or transition that you want to modify.
  
• Make the changes. The changes won't be effective until the workflow is published.
  
• After all the changes are made, click on the publish this draft link at the top of the page if you are still viewing the modified workflow. You can also click on Publish under the Operations column while viewing all the workflows.
  
• Make a copy of the old workflow, when prompted, if you need a backup, and click on Publish.
  

• You can't delete an existing workflow step
  
• You can't edit the status associated with an existing step
  
• If an existing step has no outgoing transitions, you can't add any new outgoing transitions
  
• You can't change the step IDs for any existing steps
  

• export the workflow that needs to be modified into XML. You can do it using the XML link under the Operations column of a workflow.
  
• Modify the XML to include your changes (or alternatively, make changes in a copy of the JIRA workflow and export that as XML).
  
• Stop the JIRA instance.
  
• Connect to your JIRA database.
  
• Take a backup of the existing database. We can revert to this backup if anything goes wrong.
  
• Update the JIRAWORKFLOWS table to modify the descriptor column with the new XML file for the appropriate workflow. When the workflow XML is huge, it might be useful to rely on database-specific methods to update the table. For example, we can use Oracle XML database utilities (http://download.orac...90/xdb01int.htm), if JIRA is connected to the Oracle database.
  
• Commit the changes and disconnect from the database.
  
• Start the JIRA instance.
  
• Re-index JIRA.
  

• Generic container patterns: There are several patterns that are used more than the others in code bases that use Generics. Here, we shall walk through some of these very popular generic structures.
  
• Best practices: Here we shall walk through a list of best practices with succinct causes to back them.
  

• Dictionary
  
• SortedDictionary
  
• SortedList
  
• Dictionary
  

• Mapping some class objects with a string ID
  
• Converting an enum to a string
  
• General conversion between types
  
• Find and replace algorithms where the find and replace strings become key and value pairs
  
• Implementing a state machine where each state has a description, which becomes the key, and the concrete implementation of the IState interface becomes the value of a structure such as Dictionary
  

• Dictionary>
  
• SortedDictionary>
  
• SortedList>
  
• Dictionary>
  

• Mapping all the anagrams of a given word
  
• Creating spell check where all spelling mistakes can be pre-calculated and stored as unique values
  

• Dictionary>
  
• SortedDictionary>
  
• SortedList>
  
• Dictionary>
  

• Dictionary>
  
• SortedDictionary>
  
• SortedList>
  
• Dictionary>
  

• Mapping all the grades obtained by a student. The ID of the student can be the key and the grades obtained in each subject (which may be duplicate) can be stored as the values in a list.
  
• Tracking all the followers of a Twitter account. The user ID for the account will be the key and all follower IDs can be stored as values in a list.
  
• Scheduling all the appointments for a patient whose user ID will serve as the key.
  

• If many independent values can be mapped to a set of values, then these patterns should be used. ISet implementations don't allow duplicates while ICollection implementations, such as IList, do.
  
• Imagine a company wants to give a pay hike to its employees based on certain conditions. In this situation, the parameters for conditions can be the independent variable of the Tuples, and IDs of employees eligible for the hike can be stored in an ISet implementation.
  

• Create a console app and add these four variables:
  

  	
  static int x = 11;
  	static int y = 9;
  	static int z = 20;
  	static int w = 30;	
  	
  

  
  
• Now, add these nested if-else blocks in the Main() method:
  

  	
  if (x > 9)
  	{
  	  if (y > x)
  	  {
  		if (z > y)
  		{
  		  if (w > 10)
  		  {
  			Console.WriteLine(" y > x and z > y and w > 10 ");
  		  }
  		  else
  		  {
  			Console.WriteLine(" y > x and z > y and w	   }
  		}
  		else
  		{
  		  if (w > 10)
  		  {
  			Console.WriteLine(" y > x and z  10 ");
  		  }
  		  else
  		  {
  			Console.WriteLine(" y > x and z	   }
  		}
  	  }
  	  else
  	  {
  		if (z > y)
  		{
  		  if (w > 10)
  		  {
  			Console.WriteLine(" y  y and w > 10 ");
  		  }
  		  else
  		  {
  			Console.WriteLine(" y  y and w	   }
  		}
  		else
  		{
  		  if (w > 10)
  		  {
  			Console.WriteLine(" y  10 ");
  		  }
  		  else
  		  {
  			Console.WriteLine(" y	   }
  		}
  	  }
  	}	
  	
  

  
  
• If you run this, you shall see the following output:
  

  	
  y  y and w > 10	
  	
  

  
  
• Although this code performs the job, it has the following problems:
  
  
  
  • It is very long. Most programmers will lose track of what they were reading.
    
  • It is impossible to re-use any part of the code that is available under a specific branching.
    
  
  

• We must acknowledge that by using a maximum of four variables there can be 16 different branchings. Of these only eight are shown here. This type of code can be remodeled using the following structure. Now, delete everything in the Main() method and copy the following code:
  

  	
  //Creating rules list
  	List>>
  	rules =
  	new Liststring>>>();
  	
  	//adding rules.The benefit is that entire nested if-else is
  	//flatend.
  	rules.Add(new Tupleint, string>>
  	(x > 9, y > x, z > y, w > 10, DoThis));
  	rules.Add(new Tupleint, string>>
  	(x > 9, y > x, z > y, w rules.Add(new Tupleint, string>>
  	(x > 9, y > x, z  10, DoThis));
  	rules.Add(new Tupleint, string>>
  	(x > 9, y > x, z rules.Add(new Tupleint, string>>
  	(x > 9, y  y, w > 10, DoThis));
  	rules.Add(new Tupleint, string>>
  	(x > 9, y  y, w rules.Add(new Tupleint, string>>
  	(x > 9, y  10, DoThis));
  	rules.Add(new Tupleint, string>>
  	(x > 9, y 
  	Console.WriteLine ("Printing using tuple");
  	//Finding the first rule that matches these conditions.
  	Tuple>
  	matchingRule
  				= rules.First
  				   (
  					 rule =>
  						rule.Item1 == GetExp<b></b>ression(x, 9)
  						//represents x > 9
  						&& rule.Item2 == GetExp<b></b>ression(y, x)
  						//represents y > x
  						&& rule.Item3 == GetExp<b></b>ression(z, y)
  						//represents z > y
  						&& rule.Item4 == GetExp<b></b>ression(w, 10)
  						//represents w > 10
  					  );
  	//Find the Matching function.
  	Func function = matchingRule.Item5;
  	//Invoke the function.
  	Console.WriteLine(function.Invoke(x,y,z,w));	
  	
  

  
  
• This will not compile yet because the DoThis() and GetExpression() methods are not defined. So add these methods as follows:
  

  	
  private static string DoThis(int x, int y, int z, int w)
  	{
  	  string partOne = y > x ? " y > x " : " y   string partTwo = z > y ? " z > y " : " z   string partThree = w > 10 ? " w > 10 " : " w   return partOne + "and" + partTwo + "and" + partThree;
  	}
  	
  	private static bool GetExp<b></b>ression(int x, int y)
  	{
  	  return x > y;
  	}	
  	
  

  
  

y  y and w > 10

Tuple>

Func function = matchingRule.Item5;

• Don't use Generics when you know the situation won't always be generic.
  
• Use Stack for a Last In First Out (LIFO) list implementation.
  
• Use Queue for a First In First Out (FIFO) implementation.
  
• Use List for random access lists with zero-based indexing.
  
• Use LinkedList to implement a deque because it offers faster insertion and deletion at both ends as opposed to other collections.
  
• If you have to frequently insert random locations in the list, prefer LinkedList over List because LinkedList is a constant time operation to insert one item in between two elements in a linked list.
  
• If the random list does not have a duplicate, use HashSet instead. It is the fastest.
  
• Don't use a for loop over a IDictionary implementation. It can give incorrect results. Use a foreach loop over the keys collection instead.
  
• Avoid using ElementAt() or, its cousin, the ElementAtOrDefault() method on generic collections that natively don't support zero-based integer indexing, (for example, Stack or Dictionary); since dictionary elements are not guaranteed to be available on an index where they were added.
  
• Don't use a Tuple with more than seven parameters. Create a class with those parameters and then create a list of that class' objects. Using a Tuple with more than four parameters makes the code look messy and it's not efficient.
  
• Use SortedDictionary just to get the entries sorted. Don't use it to store simple associative "one-to-one" and "one-to-many" relationships as keeping the keys sorted isn't absolutely necessary. It is very slow compared to a normal dictionary.
  
• Use HashSet to create a generic set. It's the fastest set implementation available in the .NET Framework.
  
• Use SortedSet only to create a sorted generic set. Don't use it when you don't want the set to be sorted because it is slower than HashSet.
  
• Don't expect indexing to work on an array or a list as it would on sets or dictionaries, because sets and dictionaries use hashing or tree-based internal data structures to place elements in the collection.
  
• Use the available bare minimum implementation for your customized need or resort to creating your own custom collection class from the interfaces. This is a design guideline. Try to make sure your code is as lightweight as possible. If you want a queue, use a Queue instead of a List.
  
• Use LinkedList when you need to insert elements at arbitrary positions but you don't need to access them randomly via integer indexing.
  
• Use KeyValuePair to store a key value pair. Avoid using Tuple> for this purpose because KeyValuePair is more efficient.
  
• Prefer Dictionary> over List> whenever possible for representing a one-to- many relationship between two entities. Lookup speed will be much faster and client code will be less clumsy.
  
• Prefer List> to represent a many-to-one relationship between two entities over Dictionary,TValue> if there is a duplicate.
  
• If no more entries need to be added to a collection, call TrimExcess() to free up the extra memory.
  
• Prefer LINQ Standard Query Operator Where() over Contains(), Exists(), or Find() methods to check whether a value is present in a List instance.
  
• If you implement IEnumerable in your custom collection, don't forget to implement IEnumerable also. This is to ensure backward compatibility and the Liskov substitution principle.
  
• Use SortedList if you want a concrete implementation of IDictionary that supports native indexing. However, it is slower than Dictionary. Avoid SortedList when you don't want indexing.
  
• Don't use the ElementAt() or the ElementAtOrDefault() method on IDictionary implementations except SortedList, because dictionary elements are not guaranteed to be in the index where they are added.
  
• Avoid conversions between data structure formats (for example, array to list, or vice versa using LINQ operators) as far as possible. Use other language constructs. For example, consider using a foreach loop than converting an IEnumerable instance to a list using the ToList() method before performing some operations on each item in the list.
  
• Use the OrderBy() or the OrderByDescending() method to sort any IEnumerable.
  

• Try to use built-in generic classes for maintaining internal data structures.
  
• Try to use interfaces as return type and method arguments for publicly exposed methods for your collection. For example, consider using IEnumerable over List.
  
• Try to keep the names aligned as much as possible towards the names available in frameworks. For example, if you are creating a concrete implementation of IDictionary then try to use the suffix Dictionary in the name of the class, such as MultiDictionary.
  
• Try to provide overloaded constructors to offer flexibility such that the class can be created from many diverse data sources.
  
• Use Generics constraints judiciously. Remember that these constraints are like boomerangs. You should know what exactly you can allow as an input parameter for a constrained generic type. Otherwise, these can backfire and hurt you and the users of your collection.
  
• Make sure to always implement the IEnumerable, IEnumerable, ICollection, IDisposable, and IClonable interfaces.
  
• Make sure that your collection confirms to the Liskov substitution principle. Divide into subclasses only when it makes sense, otherwise use composition.
  
• Offer a constructor overload to create a thread-safe instance of your collection.
  
• Make sure it supports LINQ, which will be obvious if you implement IEnumearble properly. LINQ is changing the way we see and solve problems. So if you miss LINQ, your collection will probably fail to impress a large section of the target audience.
  
• Thrive for performance. Make sure that performance is as best as it could be.
  
• Make sure your collection is as lightweight as possible. If a Queue can do what you want done internally in your collection, use it. Don't consider using a more versatile list implementation such as List.
  
• Don't write raw events by yourself to monitor the collection; rather expose ObservableCollection to offer this functionality.
  
• Don't provide functionalities that can be achieved by a simple combination of exposed functions. For example, take a look at the Date Time API from the .NET Framework. There is a method called AddDays() that can take a positive or negative integer such that you can go to a past or a future date. However, the framework doesn't provide a method or a public property to compute Tomorrow() or Yesterday() as they can be easily calculated using the AddDays() method. While exposing public functions for your generic collection, remember to expose only those methods that can be used as building blocks for several reasons.
  
• However, you have to strike a balance. The framework also has the AddYears() method because it will be cumbersome, although technically achievable, to duplicate AddYears() using the AddDays() method.
  

Sedge.exe /suite="C:\Apps\QuickStart.sedge"

?>
xml version="1.0" encoding="UTF-8" >
<Sedge>
  <Suite name="LunarFrog.TaggedFrog" 
	   caption="TaggedFrog Error Reporting" partial="no">
	<Schedule>
	  <Step name="Screenshot" />
	  <Step name="ErrorDetails" />
	  <Step name="Contacts" />
	  <Step name="Collect" />
	</Schedule>

	<Transport name="Email">
	  <Option name="to" value="error_mail@company.com" />
	  <Option name="subject" value="Error report" />
	</Transport>

	<Report>
	  <Group name="UserGroup" caption="User Information">
		<Page name="ImagePage" caption="Screenshot">
		  <Temp name="screenshot" caption="Screen" />
		</Page>
		<Page name="InfoPage" caption="Information">
		  <Temp name="ReportDetails" caption="Details"/>
		  <Temp name="Contacts" caption="Contact Information" />
		  <Temp name="UserFiles" />
		</Page>
	  </Group>
	  <Group name="EnvGroup" caption="Enviroment">
		<Page name="ProcessesPage" caption="Processes">
		  <Data name="Processes" />
		</Page>
		<Page name="SystemPage" caption="System">
		  <Data name="System" />
		</Page>
	  </Group>
	</Report>

	<Application name="TaggedFrog" caption="TaggedFrog">
	  <Report>
		<Group name="ApplicationGroup" caption="Application">
		</Group>
	  </Report>
	</Application>

  </Suite>
</Sedge>

• displays information provided by the user (screenshots, error details, etc.)
  
• displays information about the files - path, size, and version
  
• instructs the application to copy files to the report and print links to these files on the page
  
• is actually a meta-source; the name attribute is used to select a class implementing the IDataSource interface and returning the required information
  

• Processes to display the running processes information
  
• System to display information about the OS and the hardware
  
• Table to print the provided information in the table form; it can be used to display the information contained in the properties
  

<</span>Data name="CurrentDate" assembly="${custom.dll}" caption="Now" />

public class EchoProperty : ICustomProperty
{
	public string GetValue(Options options)
	{
		return String.Concat("Echo: ", 
		  options.GetGeneralOption("Param", "param"));
	}
}

<Properties>
	<Property name="custom.dll" 
	  value="${sedge.this.folder}\DLL\Demo.Customization.dll" />
	<CustomProperty name="echo.message" 
	  assembly="${custom.dll}" value="Echo">
		<Option name="Param" value="Hello World!" />
	</CustomProperty>
</Properties>

• Download the zip file and unzip it.
  
• Open the folder [Visual Studio 2008].
  
• Open the solution file IPC.sln. You must pre-install Visual Studio 2008 on the machine.
  
• In the Solution Explorer, open the [Process] \ [IPC and RPC] folder.
  

[b]PIPE_ACCESS_INBOUND:[/b]

Client (GENERIC_WRITE) ---> Server (GENERIC_READ)


[b]PIPE_ACCESS_OUTBOUND:[/b]

Client (GENERIC_READ) <--- Server (GENERIC_WRITE)


[b]PIPE_ACCESS_DUPLEX:[/b]

Client (GENERIC_READ or GENERIC_WRITE, or both) 
				<--> Server (GENERIC_READ and GENERIC_WRITE)

• Create a named pipe. (CreateNamedPipe)
  
• Wait for the client to connect. (ConnectNamedPipe)
  
• Read client requests from the pipe and write the response. (ReadFile, WriteFile)
  
• Disconnect the pipe, and close the handle. (DisconnectNamedPipe, CloseHandle)
  

• Try to open a named pipe. (CreateFile)
  
• Set the read mode and the blocking mode of the specified named pipe. (SetNamedPipeHandleState)
  
• Send a message to the pipe server and receive its response. (WriteFile, ReadFile)
  
• Close the pipe. (CloseHandle)
  

// Create the named pipe.
HANDLE hPipe = CreateNamedPipe(

strPipeName,					  // The unique pipe name. This string must
								  // have the form of \\.\pipe\pipename
PIPE_ACCESS_DUPLEX,			   // The pipe is bi-directional; both 
								  // server and client processes can read
								  // from and write to the pipe
PIPE_TYPE_MESSAGE |			   // Message type pipe
PIPE_READMODE_MESSAGE |		   // Message-read mode
PIPE_WAIT,						// Blocking mode is enabled
PIPE_UNLIMITED_INSTANCES,		 // Max. instances

// These two buffer sizes have nothing to do with the buffers that
// are used to read from or write to the messages. The input and
// output buffer sizes are advisory. The actual buffer size reserved
// for each end of the named pipe is either the system default, the
// system minimum or maximum, or the specified size rounded up to the
// next allocation boundary. The buffer size specified should be
// small enough that your process will not run out of nonpaged pool,
// but large enough to accommodate typical requests.

BUFFER_SIZE,					  // Output buffer size in bytes
BUFFER_SIZE,					  // Input buffer size in bytes
NMPWAIT_USE_DEFAULT_WAIT,		 // Time-out interval
&sa							   // Security attributes
)

SECURITY_ATTRIBUTES sa;
sa.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)malloc(SECURITY_DESCRIPTOR_MIN_LENGTH);
InitializeSecurityDescriptor(sa.lpSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
// ACL is set as NULL in order to allow all access to the object.
SetSecurityDescriptorDacl(sa.lpSecurityDescriptor, TRUE, NULL, FALSE);
sa.nLength = sizeof(sa);
sa.bInheritHandle = TRUE;

• P/Invoke the native APIs.
  By P/Invoke-ing the native APIs from .NET, we can mimic the code logic in CppNamedPipeServer to create the named pipe server, \\.\pipe\HelloWorld, that supports PIPE_ACCESS_DUPLEX.
  
  PInvokeNativePipeServer first creates such a named pipe, then it listens to the client's connection. When a client is connected, the server attempts to read the client's requests from the pipe and write a response.
  
• System.IO.Pipes namespace
  In .NET Framework 3.5, the namespace System.IO.Pipes and a set of classes (e.g., PipeStream, NamedPipeServerStream) are added to the .NET BCL. These classes make the programming of named pipes in .NET much easier and safer than P/Invoke-ing the native APIs directly.
  
  BCLSystemIOPipeServer first creates such a named pipe, then it listens to the client's connection. When a client is connected, the server attempts to read the client's requests from the pipe and write a response.
  

// Prepare the security attributes 
// Granting everyone the full control of the pipe is just for 
// demo purpose, though it creates a security hole. 
PipeSecurity pipeSa = new PipeSecurity(); 
pipeSa.SetAccessRule(new PipeAccessRule("Everyone", 
	   PipeAccessRights.ReadWrite, AccessControlType.Allow)); 

// Create the named pipe 
pipeServer = new NamedPipeServerStream( 
	strPipeName,					// The unique pipe name. 
	PipeDirection.InOut,			// The pipe is bi-directional 
	NamedPipeServerStream.MaxAllowedServerInstances, 
	PipeTransmissionMode.Message,   // Message type pipe 
	PipeOptions.None,			   // No additional parameters 
	BUFFER_SIZE,					// Input buffer size 
	BUFFER_SIZE,					// Output buffer size 
	pipeSa,						 // Pipe security attributes 
	HandleInheritability.None	   // Not inheritable 
);

• Create a file mapping. (CreateFileMapping)
  
• Map the view of the file mapping into the address space of the current process. (MapViewOfFile)
  
• Write message to the file view. (CopyMemory)
  
• Unmap the file view and close the file mapping objects. (UnmapViewOfFile, CloseHandle)
  

• Try to open a named file mapping. (OpenFileMapping)
  
• Maps the view of the file mapping into the address space of the current process. (MapViewOfFile)
  
• Read message from the view of the shared memory.
  
• Unmap the file view and close the file mapping objects. (UnmapViewOfFile, CloseHandle)
  

// In terminal services: The name can have a "Global\" or "Local\" prefix
// to explicitly create the object in the global or session namespace.
// The remainder of the name can contain any character except the  
// backslash character (\). For details, please refer to: 
// http://msdn.microsoft.com/en-us/library/aa366537.aspx 
TCHAR szMapFileName[] = _T("Local\\HelloWorld"); 

// Create the file mapping object 
HANDLE hMapFile = CreateFileMapping( 
	   INVALID_HANDLE_VALUE,	  // Use paging file instead of existing file. 
								  // Pass file handle to share in a file. 

	   NULL,					  // Default security 
	   PAGE_READWRITE,			// Read/write access 
	   ,						 // Max. object size 
	   BUFFER_SIZE,			   // Buffer size  
	   szMapFileName			  // Name of mapping object 
);

/// <</span>summary> 
/// Creates or opens a named or unnamed file mapping object for 
/// a specified file. 
/// <</span>/summary> 
/// <</span>param name="hFile">A handle to the file from which to create 
/// a file mapping object.<</span>/param> 
/// <</span>param name="lpAttributes">A pointer to a SECURITY_ATTRIBUTES 
/// structure that determines whether a returned handle can be 
/// inherited by child processes.<</span>/param> 
/// <</span>param name="flProtect">Specifies the page protection of the 
/// file mapping object. All mapped views of the object must be 
/// compatible with this protection.<</span>/param> 
/// <</span>param name="dwMaximumSizeHigh">The high-order DWORD of the 
/// maximum size of the file mapping object.<</span>/param> 
/// <</span>param name="dwMaximumSizeLow">The low-order DWORD of the 
/// maximum size of the file mapping object.<</span>/param> 
/// <</span>param name="lpName">The name of the file mapping object. 
/// <</span>/param> 
/// <</span>returns>If the function succeeds, the return value is a 
/// handle to the newly created file mapping object.<</span>/returns> 
[DllImport("Kernel32.dll", SetLastError = true)] 
public static extern IntPtr CreateFileMapping( 
	IntPtr hFile,				   // Handle to the file 
	IntPtr lpAttributes,			// Security Attributes 
	FileProtection flProtect,	   // File protection 
	uint dwMaximumSizeHigh,		 // High-order DWORD of size 
	uint dwMaximumSizeLow,		  // Low-order DWORD of size 
	string lpName				   // File mapping object name 
);

Client (GENERIC_WRITE) ---> Server (GENERIC_READ)

• Create a mailslot. (CreateMailslot)
  
• Check messages in the mailslot. (ReadMailslot)
  
  
  
  • Check for the number of messages in the mailslot. (GetMailslotInfo)
    
  • Retrieve the messages one by one from the mailslot. While reading, update the number of messages that are left in the mailslot. (ReadFile, GetMailslotInfo)
    
• Close the handle of the mailslot instance. (CloseHandle)
  

• Open the mailslot. (CreateFile)
  
• Write messages to the mailslot. (WriteMailslot, WriteFile)
  
• Close the slot. (CloseHandle)
  

///////////////////////////////////////////////////////////////////////// 
// Check for the number of messages in the mailslot. 
//bResult = GetMailslotInfo( 
		hMailslot,					// Handle of the mailslot 
		NULL,						 // No maximum message size 
		&cbMessageBytes,			  // Size of next message 
		&cMessages,				   // Number of messages 
		NULL);						// No read time-out

/// <</span>summary> 
/// Creates an instance of a mailslot and returns a handle for subsequent 
/// operations. 
/// <</span>/summary> 
/// <</span>param name="lpName">mailslot name<</span>/param> 
/// <</span>param name="nMaxMessageSize">The maximum size of a single message 
/// <</span>/param> 
/// <</span>param name="lReadTimeout">The time a read operation can wait for a 
/// message<</span>/param> 
/// <</span>param name="lpSecurityAttributes">Security attributes<</span>/param> 
/// <</span>returns>If the function succeeds, the return value is a handle to 
/// the server end of a mailslot instance.<</span>/returns> 
[DllImport("kernel32.dll", SetLastError = true)] 
public static extern IntPtr CreateMailslot( 
	string lpName,			  // Mailslot name 
	uint nMaxMessageSize,	   // Max size of a single message in bytes 
	int lReadTimeout,		   // Timeout of a read operation 
	IntPtr lpSecurityAttributes // Security attributes 
);

///////////////////////////////////////////////////////////////////// 
// Create and register a channel (TCP channel in this example) that 
// is used to transport messages across the remoting boundary. 
//// Properties of the channel 
IDictionary props = new Hashtable(); 
props["port"] = 6100;   // Port of the TCP channel 
props["typeFilterLevel"] = TypeFilterLevel.Full; 
// Formatters of the messages for delivery 
BinaryClientFormatterSinkProvider clientProvider = null; 
BinaryServerFormatterSinkProvider serverProvider = 
			  new BinaryServerFormatterSinkProvider(); 
serverProvider.TypeFilterLevel = TypeFilterLevel.Full; 

// Create a TCP channel 
TcpChannel tcpChannel = new TcpChannel(props, clientProvider, serverProvider); 

// Register the TCP channel 
ChannelServices.RegisterChannel(tcpChannel, true); 

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Register the remotable types on the service end as
' server-activated types (aka well-known types) or client-activated
' types.
' Register RemotingShared.SingleCallObject as a SingleCall server-
' activated type.
RemotingConfiguration.RegisterWellKnownServiceType(GetType(RemotingShared.SingleCallObject), _
					  "SingleCallService", WellKnownObjectMode.SingleCall)
' Register RemotingShared.SingletonObject as a Singleton server-
' activated type.
RemotingConfiguration.RegisterWellKnownServiceType(GetType(RemotingShared.SingletonObject), _
					  "SingletonService", WellKnownObjectMode.Singleton)
' Register RemotingShared.ClientActivatedObject as a client-
' activated type.
RemotingConfiguration.ApplicationName = "RemotingService"
RemotingConfiguration.RegisterActivatedServiceType(_
		GetType(Global.RemotingShared.ClientActivatedObject)) 

• The new ThreadPool significantly reduces the synchronization overhead associated with pushing/pulling work items to/from the pool. While in previous versions, the ThreadPool queue was implemented as a linked list protected by a big lock, the new version of the queue is based on the new array-style, lock-free, GC-friendly ConcurrentQueue class.
  
• The CLR 4.0 thread pool also supports a local queue per task, and implements a work stealing algorithm that load balances the work amongst the queues.
  
• In the 4.0 version of the CLR thread pool, the 'thread injection and retirement algorithm' has changed. In cases where there are more running threads than CPUs, instead of creating new threads at the rate of 1 thread per 0.5 second, the new thread pool takes the liberty to 'hold back' threads (i.e., reduce the concurrency level) for a while.
  

//In Static void Main
DoSomeBigStuff(1, 10000);
DoSomeBigStuff(2, 10000);

//In some class
public void DoSomeBigStuff(int inp,int limit)
{
	ProcessItem();

	if (inp > limit)
	{
		return;
	}
	DoSomeBigStuff(++inp, limit);
}

public void ProcessItem()
{
	Thread.SpinWait(100000);
}

Task t1 = new Task(() =>
{
	DoSomeBigStuff(1, 10000);
});
Task t2 = new Task(() =>
{
	DoSomeBigStuff(2, 10000);
});

ThreadPoolGlobals.workQueue.MarkThreadRequestSatisfied();

ThreadPoolWorkQueueThreadLocals tl = 
   ThreadPoolGlobals.workQueue.EnsureCurrentThreadHasQueue();

ThreadPoolGlobals.workQueue.Dequeue(tl, out callback, out missedSteal);

callback.ExecuteWorkItem();
ThreadPool.NotifyWorkItemComplete();
ThreadPoolGlobals.workQueue.EnsureThreadRequested();

				

				for (int i=0; i < 1000; i++){
					Calculate(i);
				}
				public void Calculate(int pos){
					double result = new Random().NextDouble();
					for (int i = ; i < 20000; i++){
						result += Math.Acos(new 
						Random().NextDouble());
					}
				}				
				

				

				Parallel.For(, 1000, delegate(int i)
				{
					Calculate(i);
				}
				);				
				

ForWorker<<span class="code-keyword">object>(fromInclusive, toExclusive, 
		  s_defaultParallelOptions, body, null, null, null, null);

rootTask.RunSynchronously(parallelOptions.EffectiveTaskScheduler);

• Self-replicating should have an inter-replica communication mechanism for communicating the completion of the overall activity.
  
• Only use when the cost of this communication and the management of partitions is considerably less than the potential benefit gained from parallelism.
  
• Do not assume that the task is always replicated. It is only replicated if there are available resources. For the same reason, do not assume that there will be a specific number of replicas.
  
• In some instances, the number of replicas could far exceed the number of cores in the machine.
  
• You may choose to use optimistic concurrency when it is possible to correctly deal with multiple executions of the same step.
  

• Explore working with revision graphs
  
• Learn how to change views in revision graphs
  
• Learn how to prune trees to make the revision graph easier to understand
  

• To view a revision graph, go to your working copy, and right-click inside the project, and then select TortoiseSVN | Revision Graph.
  
  

  

  
  
• The graph that appears in the following screenshot shows the history of any branches and tags created, in an easy-to-understand, tree-like structure:
  
  

  

  
  
• If you prefer to read from top to bottom, rather than having the newest node at the top of the screen, then click the Show oldest node at top button (this can be found two buttons to the right of the drop-down which allows you to change the zoom level). This will invert the view, as shown in the following screenshot:
  
  

  

  
  
• You can view information about a particular branch by right-clicking on it and selecting Show Log:
  
  

  

  
  
• You can also use the same context menu to merge revisions, switch your working copy to a particular branch or tag, browse the repository, and collapse trees.
  

• Group by Branch: This option is off by default, so all rows are sorted by revision. This can be a problem if you have branches with a long life and a few commits, because those branches will occupy a whole column, making the graph expand unnecessarily. This is demonstrated in the following screenshot:
  
  

  

  
  
  Turning on Group by Branch will change this so that revisions on a branch will be shown on consecutive lines, and branches will be grouped into columns, keeping the graph slim. The previous screenshot shows the default appearance of the revision graph (a shorter revision graph has been used here, for ease of viewing), the next screenshot shows the same revision graph with Group by Branch:
  
  

  

  
  
  With this fairly simple tree layout, the difference isn't immediately clear, but if you have a lot of branches, you'll find that the group by branch feature keeps the layout much neater, and avoids needless scrolling.
  
• Oldest on top: This option switches the graph so that the oldest revisions are shown at the top of the screen. By default, the oldest revisions are at the bottom, and the 'tree' grows upwards.
  
• Align trees on top: This option forces trees to grow down, rather than appearing in their natural revision order, or aligned at the bottom of the window.
  
• Reduce cross lines: This option cleans up the revision graph if there are lots of crossing lines. In some cases, this option can make the layout appear less logical, and can also make the graph take up a larger area of the screen.
  
• Differential path names: This option makes the path names in the node boxes as short as possible—so if you create a branch called /branches/katakana/images/characters out of /trunk/images/characters, the branch would be shown as merely /branches/katakana/.. the remainder of the path has not changed.
  
• Exact copy sources: The default behavior of the revision graph is to show branches as being taken from the last node where the change was made. In practice, many people make branches from the HEAD rather than from a specific revision. If you have a reason for needing to know which revision was used to create a copy, then you can use this option to show those details.
  
• Fold tags: If your project has a lot of tags, then you may find that they take up unnecessary screen space, hiding the information that you are interested in. You can use this option to hide the nodes for tags. If you still need to find a tag, you will find them displayed as tooltips on the node that they were copied from. Each source node that had a tag made from it will have an icon on the right-hand side indicating that a tag was made.
  
• Tree stripes: No, this option isn't related to landscape gardening. The tree stripes option tells TortoiseSVN to use alternating background colors so that it is easy to distinguish between different trees in the graph.
  

Keeping your view up-to-date
If you are viewing a revision graph of an active project, you may want to check for updates. Just as you would in your web browser, you can refresh the revision graph by pressing F5. This will connect you to the server (if you have been working offline) and check to see if there have been any new commits. Pressing F5 to refresh works for most screens in TortoiseSVN. You can update your log dialog, for example, by pressing F5 too.

• Navigate to your working copy folder.
  
• Select the file that you want to compare version history for.
  
• Right-click the file, and select TortoiseSVN | Diff with previous version.
  
  

  

  
  
• A TortoiseMerge window will appear, showing the differences between the current version of the file and the previous version.
  

(Move the mouse over the image to enlarge.)

• Navigate to the folder where the files are stored.
  
• Click on the older version of the file.
  
• Hold down the Ctrl key and then click on the newer version of the file.
  
• Right-click on the file, and select TortoiseSVN | Diff.
  
  

  

  
  
• The next window will show the differences between the two files (depending on what applications you have installed, and the file type of the file you view the differences for, your screen may differ from the following screenshot):
  

Changelists are not available for Windows 2000.
If you're a user of Windows 2000, then you won't be able to take advantage of the Changelists feature in TortoiseSVN. Unfortunately, this feature is only available for Windows XP and above. If you're still using Windows 2000 after all these years, then it's likely that you will have encountered other applications that also have problems with the operating system. Perhaps now is a good time to ask your boss for an upgrade!

• Navigate to your working copy.
  
• Right-click inside the working copy folder and select TortoiseSVN | Check for Modifications.
  
  

  

  
  
• You will see that all of the modified files appear in the status list. This might be OK for relatively small commits, but could be confusing for bigger commits. To group the files into changelists, select the files in question, right-click on them, and then select Move to changelist | .
  
  

  

  
  
• The Create Changelist window will appear. Enter a suitable name for your changelist.
  
  

  

  
  
• The files you have moved to the changelist will appear listed under that category. You can create as many changelists as you wish. The following screenshot shows two changelists for this particular commit:
  
  

  

  
  
• If you want to add a file to an already created changelist, simply right-click the file and select Move to Changelist, then click the name of the changelist in question.
  

• How to view a revision graph
  
• How to manipulate the view to your tastes
  
• How to prune trees in the graph to make your view clearer
  

• Learn the benefits of using a working copy
  
• Learn how to check out a working copy and how to check in after making changes
  
• See some of the more common commit log messages and learn what they mean
  
• Explore the repository browser
  

A word about our examples
The code snippets used in this article are incredibly simplistic. Please don't use them as examples for how to write a Python application! Also, don't worry too much about the language or IDE used in these examples. TortoiseSVN can be used with any language and any development environment. Even team members working on other areas, such as documentation or translation work, can take advantage of TortoiseSVN. The most important thing is to understand the version control principles which are being applied.

• Create a folder which you will use to store your working copies. For example, C:\Projects\MooseHiragana.
  
• Right-click inside that folder and select SVN Checkout... from the menu that appears.
  
  
  

  

  
  
• Browse to your project's repository (or enter the correct network path) and click OK.
  
  
  

  

  
  
• A window containing a list of the files which have been checked out will appear.
  
  
  

  

  
  
• If the checkout was successful, you should see a list of files in your chosen directory, with a green tick on the icon of each file.
  
  
  

  

  
  
  
  

  (Move the mouse over the image to enlarge.)

  
  

Local repositories vs. remote repositories
We will use remote repositories in most of our examples. It is likely that you will, at some point, need to work with a remote repository—either one which is accessed via the internet, or one which is part of your company's network. In that case, all you need to do is enter the full network/ internet address of the repository in the place of the file:/// reference in the URL of Repository box.

• Using a different folder for this working copy, right-click inside the folder, and select SVN Checkout....
  
• This time, in the Checkout window that appears, as well as selecting the correct repository, choose Only file children from the Checkout Depth dropdown.
  
  
  

  

  
  
• You should see that when the checkout process completes, all the files that are part of the root folder appear in your working copy, but none of the folders have been checked out.
  
  
  

  

  
  

• After you have finished editing the files that you want to change in the project, save the files and open the project folder. You should see a red exclamation mark on the icon of any files that have been changed.
  
  
  

  

  
  
• Right-click inside the folder and choose SVN Commit... (you can also right-click on a specific file, if that is the only file you wish to commit).
  
• When the Commit dialog box appears, enter a note in the Message: text box explaining the changes you have made to the file.
  
  
  

  

  
  
• Notice that the Commit box offers a spell-checking feature. Words that the spellchecker does not recognize are highlighted with a dashed red line under them. The words shown in this example are spelled correctly (pygame is the name of a Python library which is used in the application). The spell-check feature works just like the spell-checking feature in Microsoft Word—to see suggestions for alternative spellings, right-click on a highlighted word.
  
  
  

  

  
  
• Since pygame is spelled correctly, instead of choosing an alternative spelling, click Add 'pygame' to dictionary. Pygame will no longer be flagged as being spelled incorrectly.
  
• To see the differences between the original file and the modified one, double-click on the filename in the Changes made section of the dialog.
  
  
  

  

  
  
• Click OK to commit the changes.
  
• A dialog will appear showing which files have been modified and the status of the commit process.
  
  
  

  

  
  

Fixed "Bug #123 - client crashes when player submits high score" by
correcting the variable name to hiScore (matching naming convention).

Change hiscore to hiScore.

• Your IDE creates files which contain personal settings and data—the content of these files may differ from developer to developer. These files do not need to be synched, so can be excluded from the commit process permanently.
  
• Your IDE has changed the timestamp on a project file—but the rest of the file has not changed. There is no need to commit the file every time the timestamp is changed. It makes sense to exclude the file temporarily.
  

• Hold down the Shift key and right-click on the file you want to remove from versioning. This will bring up the extended context menu.
  
• Select TortoiseSVN | Delete (Keep Local).
  
• A red X icon should appear on the icon of the file you do not want to be versioned.
  
• Now right-click on the file and select SVN Commit….
  
• Once the commit has completed, right-click on the file and select TortoiseSVN | Add to Ignore List | filename
  
• You should see the ignored file get a new overlay icon (similar to the following one shown below), indicating that it has been ignored.
  
  
  

  

  
  

• Imagine that you have been making some changes to hiragana.py, and you have also decided to create a small Help feature, which is contained in a file called help.py. You are ready to commit your work on the Help feature, so you right-click on the file and select Add... to add it to the server, but you are not ready to commit hiragana.py.
  
• Right-click inside the Working Copy folder and select SVN Commit…
  
• In the window that appears, ensure that help.py is ticked and hiragana.py is un-ticked in the Changes made list.
  
  
  

  

  
  
• Now, when you click OK, only the changes to help.py will be submitted
  

Committing one file at a time
Instead of right-clicking inside the working directory folder and selecting the files you do not wish to commit, you could simply right-click on the file that you wish to commit, and open a commit dialogue for only that file (or the files that you have selected—if you have selected several files by using the Shift or Control keys and clicking on the files you want to commit). This can save you a lot of time if you wish to commit only one or two files. This approach should be used sparingly, however, because you run the risk of missing warnings about unversioned files that you would otherwise see if you committed from the root of your working copy folder.

• Bring up the TortoiseSVN context menu and select Settings.
  
• In the General section of the Settings - TortoiseSVN window which appears, add the file type or filename that you wish to ignore to the end of the list in the Global ignore patterns box (patterns are separated with a space):
  
  
  

  

  
  
• Click OK.
  

• * : This wildcard matches any string of characters—including empty strings and spaces
  
• ? : It matches any single character
  
• [...] : This matches any one of the characters contained within the brackets—for example [A-Dprz] would match the upper case characters A, B, C, or D, and the lower case characters p, r, and z
  

• To update your entire working copy, right-click inside the folder, and select SVN Update (You can update only specific files or folders by selecting them, then right-clicking on them. Developers probably wouldn't want to do this, but it is still a useful feature. An artist working remotely may choose to update only specific assets to save bandwidth.):
  
  
  

  

  
  
• An update window will appear, listing files which were added, removed, merged, or updated:
  
  
  

  

  
  

• To access the repository browser, simply right-click anywhere in an Explorer window and select TortoiseSVN | Repo Browser.
  
• The Repository Browser window will appear, as shown:
  
  
  

  

  
  
• The Repository Browser works in the same way as Windows Explorer—you can double-click on a folder to expand it. To get more information about a file, right-click on the file you are interested in—you will see several options:
  
  
  

  

  
  
• The Open and Open with... options allow you to open the file to view or edit its contents. The Show log, Revision graph, and Blame... options allow you to view information about the changes that have been made to the file.
  

• Checking out a working copy
  
• Using the checkout depth feature to check out only the parts of the repository that you need to work on
  
• Checking in your changes
  
• Excluding items from a commit
  

Do {
 Get user input
 Move characters
 Detect collisions
 Render
 } While ( Player alive)
 

For each ghost
	If ghost.MAZE_POS == pacman.MAZE_POS Then Return collision detected
Next
 Return no collision detected
 

CHARCTER.SCREEN_POS.X = CHARCTER.SCREEN_POS.X + DIRECTION HORIZONTAL DELTA
 CHARCTER.SCREEN_POS.Y = CHARCTER.SCREEN_POS.Y+DIRECTION VERTICAL DELTA
 CHARCTER .MAZE_POS.X = CHARCTER .SCREEN_POS.X / 8
 CHARCTER .MAZE_POS.Y = CHARCTER .SCREEN_POS.Y / 8
  

PACMAN.SCREEN_POSITION.X = 100
 GHOST.SCREEN_POSITION.X = 100
PACMAN.SCREEN_POSITION.Y = 7
 GHOST.SCREEN_POSITION.Y = 8
 PACMAN.DIRECTION = DOWN
 GHOST.DIRECTION = UP
 

PACMAN.MAZE_POSITION.X = PACMAN.SCREEN_POSITION.X/8  // 100/8 = 12
 PACMAN.MAZE_POSITION.Y = PACMAN.SCREEN_POSITION.Y/8  // 7/8 = 0
 GHOST.MAZE_POSITION.X =GHOST.SCREEN_POSITION.X/8  // 100/8 = 12
 GHOST.MAZE_POSITION.Y = GHOST.SCREEN_POSITION.Y/8  // 8/8 = 1
 

PACMAN.MAZE_POSITION (12,0) != GHOST.MAZE_POSITION(12,1)

PACMAN. SCREEN_POSITION.X = PACMAN.SCREEN_POSITION.X +0   // stays 100
 PACMAN. SCREEN_POSITION.Y = PACMAN.SCREEN_POSITION.Y +1  // now it is 8
 GHOST. SCREEN_POSITION.X =GHOST.SCREEN_POSITION.X + 0 //stays 100
 GHOST. SCREEN_POSITION.Y = GHOST.SCREEN_POSITION.Y +(-1)  // now it is 7
  PACMAN.MAZE_POSITION.X = PACMAN.SCREEN_POSITION.X/8  // 100/8 = 12
 PACMAN.MAZE_POSITION.Y = PACMAN.SCREEN_POSITION.Y/8  // 8/8 = 1
 GHOST.MAZE_POSITION.X =GHOST.SCREEN_POSITION.X/8  // 100/8 = 12
 GHOST.MAZE_POSITION.Y = GHOST.SCREEN_POSITION.Y/8  // 7/8 = 0
 

PACMAN.MAZE_POSITION (12,1) != GHOST.MAZE_POSITION(12,0)

• Are they even going to take care of you if the do go out of business?
• Will they delete your account tomorrow because you haven't worked on your project for a few weeks?
• Can they afford to put in the resources to ensure that your project isn't one server crash away from being lost?

- Michael Tanczos
CTO, GameDev.net

• Communicated with your team via email about updates.
• Made updates directly on your production server.
• Accidentally overwrote some files, which can never be retrieved again.

• File names and directory structures that are consistent for all team members.
• Making changes with confidence, and even reverting when needed.
• Relying on source control as the communication medium for your team.
• Easily deploying different versions of your code to staging or production servers.
• Understanding who made a change and when it happened.

• It is easy to understand.
• You have more control over users and access (since it is served from one place).
• More GUI & IDE clients (Subversion has been around longer).
• Simple to get started.

• Dependent on access to the server.
• Hard to manage a server and backups (well, not with Beanstalk of course!)
• It can be slower because every command connects to the server.
• Branching and merging tools are difficult to use.

• More powerful and detailed change tracking, which means less conflicts.
• No server necessary – all actions except sharing repositories are local (commit offline).
• Branching and merging is more reliable, and therefore used more often.
• It’s fast.

• The distributed model is harder to understand.
• It’s new, so not as many GUI clients.
• The revisions are not incremental numbers, which make them harder to reference.
• It’s can be easier to make mistakes until you are familiar with the model.

• Although this should never really be an issue, an any_ptr occupies more space than a raw void pointer (its size is a void pointer plus an integer).
• Casting from an any_ptr is slower than casting from a void pointer. Again this should never really be an issue.
• Casting to base class pointers from an any_ptr will not work. This was pointed out to me by the thorough GameDev.net review staff.

• Microsoft Visual C++ 2005/2008/2010
• gcc 4.4.1 (TDM-2 mingw32)

• Callback (computer science), from Wikipedia
• Smart pointer, from Wikipedia
• Boost.Any, from Boost Library Documentation
• Const correctness, from C++ FAQ Lite
• Exception handling, from Wikipedia
• Run-time type information, from Wikipedia

• Lessons on development of 64-bit C/C++ applications [1];
• About size_t and ptrdiff_t [2];
• 20 issues of porting C++ code on the 64-bit platform [3];
• PVS-Studio Tutorial [4];
• A 64-bit horse that can count [5].

• Andrey Karpov, Evgeniy Ryzhkov. Lessons on development of 64-bit C/C++ applications. http://www.viva64.co...es/x64-lessons/
• Andrey Karpov. About size_t and ptrdiff_t. http://www.viva64.co...-710804781.html
• Andrey Karpov, Evgeniy Ryzhkov. 20 issues of porting C++ code on the 64-bit platform. http://www.viva64.co...-599168895.html
• Evgeniy Ryzhkov. PVS-Studio Tutorial. http://www.viva64.co...-747004748.html
• Andrey Karpov. A 64-bit horse that can count. http://www.viva64.co...-377673569.html

• Linear response curve: The maximum speed increases proportionally to the stamina bar. (fCurrentMaxSpeed = MAXSPEED * fStaminaBarValue)
• Quadratic response curve: When the stamina is lower, the max-speed changes slower than when the stamina is higher. (fCurrentMaxSpeed = MAXSPEED * fStaminaBarValue * fStaminaBarValue)
• More complex: It is a mix between the linear and quadratic, with a minimum speed of 0.2*MAXSPEED , but it could be whatever equation. (fCurrentMaxSpeed = MAXSPEED * ( 0.2 + ( fStaminaBarValue * fStaminaBarValue + fStaminaBarValue ) * 0.4f ))

• The constructor, that has as input parameters the data read from the XML, the curve name and the array of its inputs and outputs. (e.g. ResponseCurve (string curveName, float inputs[], float outputs[]) )
• The function that returns the output for each specific input. (float GetResult (float input) )

• The initial animation sequence ( this event can only be triggered from this state).
• The change condition (what happened that would cause this sequence to change?)
• A priority (if the conditions of several animations are fulfilled in the same game frame, which to use?)
• A final animation sequence

• loads objects from a "C" style format which is easy to read and edit using any plain text editor
• extremely simple to integrate and use
• portable code; implemented in standard C++
• does not require loadable types to derive from a specific base class
• does not add any overhead (in terms of space/time) to the types it can load
• non-intrusive loading support for types which cannot be modified (e.g., library types)
• built-in support for the following STL containers: string, vector, list, deque, pair, map, multimap, set, multiset
• supports loading enumerations^[1]
• supports loading pointers
  • supports data-structures which form graphs
  • supports forward pointers to objects
  • supports (polymorphic and non-polymorphic) pointers to objects of derived types
• handles multiple inheritance (although it cannot handle virtual base classes as yet)
• does not require RTTI to be enabled
• does not require exceptions to be enabled

Note: If you don't have an SVN client and you're on Windows, then I'd recommend getting TortoiseSVN. If you're on Linux, then you could try eSvn

• const bool FromFile(const string &fileName);
  • Specifies which file the Reader should read from.
• const bool Read(T &obj);
  • Reads a required object of any type.
  • Data format: <object>
• const bool Read(const string &name, T &obj);
  • Reads a required object of any type, associated with an identifier (like a name/value pair).
  • Data format: <identifier> = <object>;
• const bool Read(const string &name, T &obj, const T &defaultValue);
  • Reads an optional object of any type, associated with an identifier; if not present, the specified default value is used.
  • Data format: [<identifier> = <object>;]

#include "Daabli.h"
#include <iostream>

struct SpaceShip
{
  char    _type;
  float   _maxSpeed;
  float   _mass;
  bool    _invulnerable;
};

int main(int /*argc*/, char * /*argv*/[])
{
// Create a Reader object
Daabli::Reader r;

// Specify which file to read from
if( !r.FromFile( "input.txt" ) )
  return -1;

SpaceShip ship;

// Read the space ship's properties
if( !r.Read( "type", 		ship._type                ) || 	// required
    !r.Read( "maxSpeed", 	ship._maxSpeed            ) || 	// required
    !r.Read( "mass", 		ship._mass, 		10.0f ) || 	// optional
    !r.Read( "invulnerable", ship._invulnerable, false ) )      // optional
    return -1;

// Display the space ship's properties
std::cout << "type 		: " << ship._type 		<< std::endl;
std::cout << "maxSpeed 	: " << ship._maxSpeed 	<< std::endl;
std::cout << "mass 		: " << ship._mass 		<< std::endl;
std::cout << "invulnerable : " << ship._invulnerable << std::endl;

return 0;
}

/* Player ship properties */
type 		= 'A';
maxSpeed 	= 10.2;
mass 		= 50.7;
//invulnerable = true;

#include "Daabli.h"
#include <iostream>

typedef std::map<int, float> LevelPriceMap;
typedef std::vector<float> Row;
typedef std::vector<Row>   Matrix;

struct Item
{
    std::string 	_name;
    LevelPriceMap   _levelPrices;
    Matrix          _transform;
};

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    Item item;

    // Read the item properties
    if( !r.Read( "name",        item._name        ) ||
        !r.Read( "levelPrices", item._levelPrices ) ||
        !r.Read( "transform",   item._transform   ) )
        return -1;

    // Display the item properties
    {
        std::cout << "Item Properties" << std::endl;
        std::cout << "Name: " << item._name << std::endl;

        for(LevelPriceMap::const_iterator itr = item._levelPrices.begin();
            itr != item._levelPrices.end(); ++itr)
        {
            std::cout << "Price at Level " << itr->first << ": " << itr->second << std::endl;
        }

        std::cout << "Transformation: " << std::endl;
        for(std::size_t j=0; j < item._transform.size(); ++j)
        {
            for(std::size_t i=0; i < item._transform[j].size(); ++i)
                std::cout << item._transform[j][i] << " ";

            std::cout << std::endl;
        }
    }

    return 0;
}

/* Item properties */

name = "Small Healing Potion";

levelPrices = // Level => Price
{
    { 1, 10.5 },
    { 2, 15   },
    { 3, 16.5 }, // modest price increase at this level
    { 4, 20   }
};

transform = // identity matrix; no transformation
{
    { 1, 0, 0 },
    { 0, 1, 0 },
    { 0, 0, 1 }
};

#include "Daabli.h"
#include <iostream>

struct SpaceShip
{
    char    _type;
    float   _maxSpeed;
    float   _mass;
    bool    _invulnerable;

    // Support the intrusive reading method
    const bool Read(Daabli::Reader &r)
    {
        return
            r.Read( "type", 		_type                ) &&
            r.Read( "maxSpeed", 	_maxSpeed            ) &&
            r.Read( "mass", 		_mass                ) &&
            r.Read( "invulnerable", _invulnerable, false );
    }
};

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    std::list<SpaceShip> ships;

    // Read the list of space ships
    if( !r.Read( "ships", ships ) )
        return -1;

    // Display the list of space ships
    for(std::list<SpaceShip>::const_iterator itr = ships.begin(); itr != ships.end(); ++itr)
    {
        std::cout << "type 		: " << (*itr)._type 		<< std::endl;
        std::cout << "maxSpeed 	: " << (*itr)._maxSpeed 	<< std::endl;
        std::cout << "mass 		: " << (*itr)._mass 		<< std::endl;
        std::cout << "invulnerable : " << (*itr)._invulnerable << std::endl;
        std::cout << std::endl;
    }

    return 0;
}

ships =
{
    // Drone ship
    {
        type 	= 'D';
        maxSpeed = 10.2;
        mass 	= 50.7;
    },
    
    // Fighter ship
    {
        type 	= 'F';
        maxSpeed = 22.4;
        mass 	= 25.1;
    },
    
    // Shop ship
    {
        type 		= 'S';
        maxSpeed 	= 0;
        mass 		= 100;
        invulnerable = true;
    }
};

class A
{
    /* A's members go here */
public:
    const bool Read(Daabli::Reader &r)
    {
        /* Read A's members here */
        return true;
    }
};

class B
{
    /* B's members go here */
public:
    const bool Read(Daabli::Reader &r)
    {
        /* Read B's members here */
        return true;
    }
};

class C : public A, public B
{
    /* C's members go here */
public:
    const bool Read(Daabli::Reader &r)
    {
        // Read bases
        if( !r.Read<A>( *this ) ||
            !r.Read<B>( *this ) )
            return false;

        /* Read C's members here */
        return true;
    }
};

namespace Daabli
{
    template <class T> struct ObjectReader
    {
        // Must be true in all specializations
        enum { exists = true };
        // Could be true or false as required in specializations
        enum { group = false };

        // Define this function for specializations
        static const bool Read(T &obj, Reader &r);
    };
}

struct Point
{
    int x;
    int y;
};

namespace Daabli
{
    template <> struct ObjectReader<Point>
    {
        enum { exists = true };
        enum { group = false };

        static const bool Read(Point &obj, Reader &r)
        {
            // Read a Point of the form: <x>, <y>
            return
                r.Read( obj.x ) && r.ReadSeparator() &&
                r.Read( obj.y );
        }
    };
}

#include "Daabli.h"
#include <iostream>

struct Point
{
    int x;
    int y;
};

namespace Daabli
{
    template <> struct ObjectReader<Point>
    {
        enum { exists = true };
        enum { group = false };

        static const bool Read(Point &obj, Reader &r)
        {
            // Read a Point of the form: <x>, <y>
            return
                r.Read( obj.x ) && r.ReadSeparator() &&
                r.Read( obj.y );
        }
    };
}

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    Point p;

    // Read the Point
    if( !r.Read( "point", p ) )
        return -1;

    // Display the point
    std::cout << "Point: " << p.x << ", " << p.y << std::endl;

    return 0;
}

point = 10, 20;

template <class T>
struct Point
{
    T   x;
    T   y;
};

namespace Daabli
{
    template <class T> struct ObjectReader<Point<T> >
    {
        enum { exists = true };
        enum { group = false };

        static const bool Read(Point<T> &obj, Reader &r)
        {
            // Read a Point of the form: <x>, <y>
            return
                r.Read( obj.x ) && r.ReadSeparator() &&
                r.Read( obj.y );
        }
    };
}

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    Point<int>          p1;
    Point<float>        p2;
    Point<std::string>  p3;

    // Read the points
    if( !r.Read( "point<int>",    p1 ) ||
        !r.Read( "point<float>",  p2 ) ||
        !r.Read( "point<string>", p3 ) )
        return -1;

    // Display the points
    std::cout << "Point<int>    : " << p1.x << ", " << p1.y << std::endl;
    std::cout << "Point<float>  : " << p2.x << ", " << p2.y << std::endl;
    std::cout << "Point<string> : " << p3.x << ", " << p3.y << std::endl;

    return 0;
}

point<int>    = 10, 20;
point<float>  = 10.2, 20.4;
point<string> = "Hello", "World";

• Re-declare the enumeration in a different format for conversion support to/from string (see section “String conversion support”).
• Declare the enumeration as 'readable' by Daabli.

// Furious Five Master
enum Master
{
    Tigress = 5,
    Viper = 3,
    Monkey = 4,
    Mantis = 1,
    Crane = 2
};

// String conversion support
Daabli_Begin_Enum( Master )
{
    Daabli_Enum( Tigress );
    Daabli_Enum( Viper );
    Daabli_Enum( Monkey );
    Daabli_Enum( Mantis );
    Daabli_Enum( Crane );
}
Daabli_End_Enum;

// Reading support
Daabli_Readable_Enum( Master );

[/cint main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    Master myMaster;

    if( !r.Read( "myMaster", myMaster ) )
        return -1;

    std::cout << "myMaster: " << myMaster << std::endl;

    return 0;
}

myMaster = Monkey;

value  = [myValue] 10;  // Integer object named 'myValue'
pValue = [myValue]; 	// Integer pointer, pointing to the object whose name is 'myValue'.

int  value;
int *pValue;

if( !r.Read( "value",  value  ) ||
    !r.Read( "pValue", pValue ) )
    return -1;

std::cout << "&value: " << &value << std::endl; // Outputs address of 'value'
std::cout << "pValue: " << pValue << std::endl; // Outputs NULL

if( !r.ResolvePointers() )
    return -1;  // Handle error

std::cout << "pValue: " << pValue << std::endl; // Outputs address of 'value'

pValue1 = (int) 10; 			// Pointer to dynamically allocated int
pValue2 = (int) [myValue] 20;   // Pointer to dynamically allocated int, named 'myValue'
pValue3 = [myValue];            // Pointer to the object whose name is 'myValue'

int *pValue1;
int *pValue2;
int *pValue3;

if( !r.Read( "pValue1", pValue1 ) ||
    !r.Read( "pValue2", pValue2 ) ||
    !r.Read( "pValue3", pValue3 ) )
    return -1;

// Resolve pointers
if( !r.ResolvePointers() )
    return -1;  // Handle error

std::cout << "value1: " << (*pValue1) << std::endl; // Outputs 10
std::cout << "value2: " << (*pValue2) << std::endl; // Outputs 20
std::cout << "value3: " << (*pValue3) << std::endl; // Outputs 20

delete pValue1;
delete pValue2;
//delete pValue3; // Same as pValue2

#include "Daabli.h"
#include <iostream>

struct Item
{
    virtual ~Item() =0
    {
    }
    virtual void Display() =0;
};

Daabli_Register_Type( Daabli_Abstract, Item );

class Sword : public Item
{
    std::string _name;
public:
    virtual void Display()
    {
        std::cout << "Sword: " << _name << std::endl;
    }
    const bool Read(Daabli::Reader &r)
    {
        return r.Read( "name", _name );
    }
};

Daabli_Register_Type_Base1( Daabli_Concrete, Sword, Item );

class HealingPotion : public Item
{
    int _pointsHealed;
public:
    virtual void Display()
    {
        std::cout << "Healing Potion: " << _pointsHealed << std::endl;
    }
    const bool Read(Daabli::Reader &r)
    {
        return r.Read( "pointsHealed", _pointsHealed );
    }
};

Daabli_Register_Type_Base1( Daabli_Concrete, HealingPotion, Item );

struct Armor : public Item
{
    float _damageReduction;
public:
    virtual void Display()
    {
        std::cout << "Armor: " << _damageReduction << std::endl;
    }
    const bool Read(Daabli::Reader &r)
    {
        return r.Read( "damageReduction", _damageReduction );
    }
};

Daabli_Register_Type_Base1( Daabli_Concrete, Armor, Item );

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    typedef std::list<Item*> Items;

    // Read a list of items
    Items items;
    if( !r.Read( "myItems", items ) )
        return -1;

    // Resolve pointers
    if( !r.ResolvePointers() )
        return -1;

    // Display the list of items
    for(Items::const_iterator itr = items.begin(); itr != items.end(); ++itr)
        (*itr)->Display();

    // Delete all the items in the list
    for(Items::const_iterator itr = items.begin(); itr != items.end(); ++itr)
        delete (*itr);

    return 0;
}

myItems =
{
    (HealingPotion) { pointsHealed = 10; },
    (HealingPotion) { pointsHealed = 12; },
    (Sword) 		{ name = "Great Stinging Sword"; },
    (Armor) 		{ damageReduction = 50; }
};

#include "Daabli.h"
#include 

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;

    if( !r.FromFile( "input.txt" ) )
        return -1;

    // Read an integer
    int value;
    r.Read( "myValue", value );

    // Display error messages if any
    Daabli::MessageLog::MessageList::const_iterator itr = r.Log.Messages().begin();
    while( itr != r.Log.Messages().end() )
    {
        std::cout << "At line number   : " << itr->first.first  << std::endl;
        std::cout << "At column number : " << itr->first.second << std::endl;
        std::cout << "Error message    : " << itr->second   	<< std::endl;
        std::cout << std::endl;

        ++itr;
    }

    return 0;
}

myValue = 10.2;  

#include "Daabli.h"
#include <iostream>

struct ClownHero
{
    int _health;
    int _ammo;

    const bool Read(Daabli::Reader &r)
    {
        // Read and validate health
        {
            if( !r.Read( "health", _health ) )
                return false;

            if((_health < 1) || (_health > 100))
            {
                r.Log << "Invalid value for health (1 to 100): "
                      << Daabli::ToString(_health) << Daabli::endl;
                return false;
            }
        }

        // Read and validate ammo
        {
            if( !r.Read( "ammo", _ammo ) )
                return false;

            if((_ammo < 0) || (_ammo > 1000))
            {
                r.Log << "Invalid value for ammo (0 to 1000): "
                      << Daabli::ToString(_ammo) << Daabli::endl;
                return false;
            }
        }

        return true;
    }
};

int main(int /*argc*/, char * /*argv*/[])
{
    Daabli::Reader r;
    if( !r.FromFile( "input.txt" ) )
        return -1;

    // Read a hero
    ClownHero hero;
    if( !r.Read( "hero", hero ) )
        return -1;

    // Display the hero's properties
    std::cout << "Clown Hero Properties" << std::endl;
    std::cout << "Health: " << hero._health << std::endl;
    std::cout << "Ammo  : " << hero._ammo << std::endl;

    return 0;
}

hero =
{
    health = 100;
    ammo = 1500;
};

• const string ToString(const T &val);
  • Converts an object to its string representation; returns the string.
• const bool FromString(T &val, const string &str);
  • Converts a string to an object; returns true if the conversion was successful, false otherwise.

const int value = 256;
std::cout << value << std::endl;    // outputs 256

const std::string valueStr = Daabli::ToString( value );
std::cout << valueStr << std::endl; // outputs 256

int newValue = 0;
Daabli::FromString( newValue, valueStr );
std::cout << newValue << std::endl; // outputs 256

#include "Daabli.h"
#include <iostream>

// Weekend day
enum Weekend
{
    Sunday,
    Saturday
};

// String conversion support
Daabli_Begin_Enum( Weekend )
{
    Daabli_Enum( Sunday );
    Daabli_Enum( Saturday );
}
Daabli_End_Enum;

int main(int /*argc*/, char * /*argv*/[])
{
    Weekend day = Sunday;
    
    // Convert the string "Saturday" into a day
    if( !Daabli::FromString( day, "Saturday" ) )
        return -1;

    // Convert the day back into a string
    const std::string dayStr = Daabli::ToString( day );

    std::cout << dayStr << std::endl;    // outputs Saturday

    return 0;
}

namespace Daabli
{
    template <class T> struct StringConverter
    {
        // Must be true in all specializations
        enum { exists = true };

        // Define these functions for specializations
        static const std::string ToString(const T &val);
        static const bool FromString(T &val, const std::string &str);
    };
}

#include "Daabli.h"
#include <iostream>

struct Color
{
    typedef unsigned char Byte;

    Byte _r;
    Byte _g;
    Byte _b;

    const bool IsRed() const    { return (_r == 255) && (_g == 0  ) && (_b == 0  ); }
    const bool IsGreen() const  { return (_r == 0  ) && (_g == 255) && (_b == 0  ); }
    const bool IsBlue() const   { return (_r == 0  ) && (_g == 0  ) && (_b == 255); }

    void Set(const Byte r, const Byte g, const Byte <img src='[url="[url="http://public.gamedev.net/public/style_emoticons/"]http://public.gamedev.net/public/style_emoticons/[/url]"][url="http://public.gamedev.net/public/style_emoticons/"]http://public.gamedev.net/public/style_emoticons/[/url][/url]<#EMO_DIR#>/cool.gif' class='bbc_emoticon' alt='B)' />
    {
        _r = r; _g = g; _b = b;
    }
};

namespace Daabli
{
    template <> struct StringConverter<Color>
    {
        enum { exists = true };

        static const std::string ToString(const Color &val)
        {
            if( val.IsRed()   ) return std::string( "Red" );
            if( val.IsGreen() ) return std::string( "Green" );
            if( val.IsBlue()  ) return std::string( "Blue" );
            return std::string( "Unknown" );
        }

        static const bool FromString(Color &val, const std::string &str)
        {
            if( str.compare( "Red"   ) == 0 ) { val.Set( 255,   0,   0 ); return true; }
            if( str.compare( "Green" ) == 0 ) { val.Set(   0, 255,   0 ); return true; }
            if( str.compare( "Blue"  ) == 0 ) { val.Set(   0,   0, 255 ); return true; }
            return false;
        }
    };
}

int main(int /*argc*/, char * /*argv*/[])
{
    Color color = { 0, 0, 0 };

    // Convert the string "Red" into a color
    if( !Daabli::FromString( color, "Red" ) )
        return -1;

    // Convert the color back into a string
    const std::string colorStr = Daabli::ToString( color );

    std::cout << colorStr << std::endl; // outputs Red

    return 0;
}

• Microsoft Visual C++ 2005/2008
• GCC 4.3.2

• the product to be created doesn't fall within that hierarchy (i.e., it's a base product, or an unrelated product).
  
• the product to be created was not (or incorrectly) registered with its associated factory.
  
• one of the products in the hierarchy was not (or incorrectly) registered, thereby breaking the "chain" of creation delegation.
  

• Very easy to use and maintain.
  
• Exposes a single unified interface to create all objects.
  
• Doesn't require RTTI.
  
• Doesn't require the objects to be polymorphic.
  
• No overhead is added to objects (in terms of time/space).
  
• Supports primitive types (float, unsigned int, etc.)
  
• Supports (instantiated) templated types. (see Example4 in accompanying code)
  
• Can provide Factory services to existing classes without any modifications.
  

• The implementation provided only has out of the box support for objects which have a public parameterless constructor. However, bypassing the normal registration macros allows you to provide your own functions to create objects, so you can use that to customize object creation. (Otherwise you can always hack the code to support your specific needs (: ).
  
• Requires some maintenence if class hierarchies change (but usually, that's not something which happens too frequently).
  
• A linear search is employed to find the required object type. The time taken depends on the hierarchical "distance" between the target type and the type to be returned. Normally this shouldn't be a problem, unless you have *extremely* deep class hierarchies.
  

• Microsoft Visual C++ 2005/2008
  
• GCC 4.3.2
  

• refrain from visiting nodes having no associated point in Δ (i.e. 3.3)
• maximize the probability P_ideal so that each node N splits its associated set into two subsets, one set entirely sought and one set entirely non-sought (i.e. 3.2)
• If the set of points associated with a node is sought, then we shall visit the same number of nodes in the sub-tree, irrespective of the heuristic (except in the case of ancillary optimizations that may be added to the traversal algorithm). Thus, this case is not significant.