[[BackLinksMenu]]

[[TicketQuery(summary=PRO_LIB_CORE_MISUSE_DETECTION_R0, format=table, col=summary|owner|status|type|component|priority|effort|importance, rows=description|analysis_owners|analysis_reviewers|analysis_score|design_owners|design_reviewers|design_score|implementation_owners|implementation_reviewers|implementation_score|test_owners|test_reviewers|test_score|)]]



= Analysis =

== Overview ==
The aim of this task is to identify irregular uses of Properties Library that could be either frequent or hard to find. An example of irregular use is :
 public RwProp<Integer> fish() {
   return getBean().makeValueProp("fish", Integer.class, complextMethodToComputeFish());
 }
 because the third argument must be a constant.

== Task requirements ==
 1. Write a list with irregular uses - at least 3[[BR]]
 2. Add some checks or asserts to protect from irregular uses[[BR]]
 3. Make tests, which identify irregular uses.[[BR]]

== Task result ==
The result of this task should be source code

== Implementation idea ==
Prolib is a complex library. It is easy to use it irregular . It is hard to find the irregular uses,  so it must have lots of conversations between teams. There is some ways to protect from irregular uses :
 1. using a compilator [[BR]]

 2. using exceptions[[BR]]

== Related ==
[wiki:PRO_LIB_CORE_COMMONS_R0]

== How to demo ==
Explain the misuses to the team

= Design =

 * Irregular pro lib uses:
  * create method of resource property should not be dependent on any property except for final properties.
  * value properties that are initialized at their invocation
   * should be initialized with ONLY the following:
    * constant primitive types.
    * immutable objects that are not going to change later.
    * final references to objects.
   * should not set their value by a complex code invocation: 
{{{
public RwProp<Integer> fish() {
   return getBean().makeValueProp("fish", Integer.class, complextMethodToComputeFish());
 }
}}}
  * properties of objects that are alike properties of other objects should create the former instead of returning them directly:
{{{
      class Dummy extends BaseProObject{
		public RwProp<String> text() {
			return getBean().makeValueProp("text", String.class, new String("this is a string."));
		}
	}
	
	class DummyDependent extends BaseProObject{
		
		public DummyDependent(Dummy dummy) {
			dummy().set(dummy);
		}
		
		public RwProp<Dummy> dummy() {
			return getBean().makeValueProp("dummy", Dummy.class);
		}
		
                //THIS SHOULD NOT BE POSSIBLE
		public RwProp<String> textOfDummy() {
			return dummy().get().text();
		}
		
	}
}}}

 * Misuse detection shall be done through checks and exception throwing.
  * create method of resource property should not be dependent on any property except for final properties - the check should be made on !ResourceProperty creation.
  * value properties that are initialized at their invocation - things should be checked and exception thrown - not sure how to to this for the time being.
  * properties of objects that are alike properties of other objects should create the former instead of returning them directly - should check in !ProObject's methods that return properties that they construct new ones instead of reusing others.
 * A unit test for the 3 types of irregular use will be written.

= Implementation =
^(Implementation results should be described and linked here (from the wiki or the repository))^

= Testing =

= Comments =
^(Write comments for this or later revisions here.)