SCHEMA all_tasks_are_periodic_constraint;
	USE FROM Tasks;

	RULE all_tasks_are_periodic FOR ( generic_task );
	WHERE
		R4 : SIZEOF ( QUERY ( t <* generic_task |
				 NOT ( 'TASKS.PERIODIC_TASK' IN TYPEOF ( t ) ) ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA Static_priorities_RM_EDF_DM_constraint;
	USE FROM Scheduler;

	RULE Static_priorities_RM_EDF_DM FOR ( Generic_Scheduler );
	WHERE
		R1 : SIZEOF ( QUERY ( s <* generic_scheduler |
				 NOT ( 'SCHEDULER.EARLIEST_DEADLINE_FIRST_PROTOCOL' IN
					 TYPEOF ( s ) ) OR
				 ( 'SCHEDULER.RATE_MONOTONIC_PROTOCOL' IN TYPEOF ( s ) ) OR
				 ( 'SCHEDULER.DEADLINE_MONOTONIC_PROTOCOL' IN
					 TYPEOF ( s ) ) OR
				 ( 'SCHEDULER.POSIX_1003_HIGHEST_PRIORITY_FIRST_PROTOCOL' IN
					 TYPEOF ( s ) ) ) ) =
		 0;
	END_RULE;
END_SCHEMA;

SCHEMA Preemptive_or_not_preemptive_constraint;
	USE FROM Scheduler;
	USE FROM Scheduler_Interface;

	RULE Preemptive_or_not_preemptive FOR ( Generic_Scheduler );
	WHERE
		R2 : SIZEOF ( QUERY ( s <* generic_scheduler |
				 ( s.parameters.preemptivity <> preemptive ) OR
				 ( s.parameters.preemptivity <> not_preemptive ) ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA Quantum_equals_zero_constraint;
	USE FROM Scheduler;
	USE FROM Scheduler_Interface;

	RULE Quantum_equals_zero FOR ( Generic_Scheduler );
	WHERE
		R3 : SIZEOF ( QUERY ( s <* generic_scheduler |
				 s.parameters.quantum <> 0 ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA no_shared_resources_constraint;
	USE FROM Resources;

	RULE no_shared_resources FOR ( Generic_Resource );
	WHERE
		R6 : ( SIZEOF ( Generic_Resource ) = 0 );
	END_RULE;
END_SCHEMA;

SCHEMA no_shared_cpu_constraint;
	USE FROM Address_spaces;

	RULE no_shared_cpu FOR ( Address_space );
	WHERE
		R7 : SIZEOF ( QUERY ( a1 <* Address_space |
				 SIZEOF ( QUERY ( a2 <* Address_space |
						 ( ( a1 <> a2 ) AND
							 ( a2.Cpu_Name = a1.Cpu_Name ) ) ) ) > 0 ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA all_tasks_are_periodic_or_sporadic_constraint;
	USE FROM Tasks;

	RULE All_Tasks_Are_Periodic_or_sporadic FOR ( Generic_Task );
	WHERE
		R8 : SIZEOF ( QUERY ( t <* generic_task |
				 NOT ( ( 'TASKS.PERIODIC_TASK' IN TYPEOF ( t ) ) OR
					 NOT ( 'TASKS.SPORADIC_TASK' IN TYPEOF ( t ) ) ) ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA At_Least_One_Data_constraint;
	USE FROM Resources;

	RULE At_Least_One_Data FOR ( Generic_Resource );
	WHERE
		R9 : SIZEOF ( generic_resource ) > 0;
	END_RULE;
END_SCHEMA;

SCHEMA No_Buffer_constraint;
	USE FROM Buffers;

	RULE No_Buffer FOR ( Buffer );
	WHERE
		R5 : SIZEOF ( Buffer ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA Data_Connectivity_constraint;
	USE FROM Resources;
	USE FROM Dependencies;

	RULE Data_Connectivity FOR ( Generic_Resource, Resource_Dependency_Type );
	WHERE
		R10 : SIZEOF ( QUERY ( r <* Generic_Resource |
				 SIZEOF ( QUERY ( d <* Resource_Dependency_Type |
						 d.resource_dependency_resource = r ) < 2 ) ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA Allowed_Protocol_constraint;
	USE FROM Resources;

	RULE Allowed_Protocol FOR ( Generic_Resource );
	WHERE
		R11 : SIZEOF ( QUERY ( r <* Generic_Resource |
				 NOT ( r.protocol IN [ Priority_Ceiling_Protocol,
						 Priority_Inheritance_Protocol,
						 Immediate_Priority_Ceiling_Protocol] ) ) ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA Ceiling_Priority_assignment_constraint;
	USE FROM Resources;
	USE FROM Dependencies;

	(* si pcp ou ipcp alors le ceiling_priority doit être >= 
	de la priority des taches qui utilisent le Generic_Resource *)
	RULE Ceiling_Priority_assignment FOR ( Generic_Resource,
			 Resource_Dependency_Type );
	WHERE
		R12 : SIZEOF ( QUERY ( d <* Resource_Dependency_Type |
				 ( d.protocol IN [ Priority_Ceiling_Protocol,
						 Immediate_Priority_Ceiling_Protocol] ) AND
				 ( d.resource_dependency_resource.ceiling_priority <
					 d.resource_dependency_task.Priority ) ) ) =
		 0;
	END_RULE;
END_SCHEMA;

SCHEMA No_Hierarchical_Scheduling_constraint;
	USE FROM Deployments;

	RULE No_Hierarchical_Scheduling FOR ( Generic_Deployment );
	WHERE
		R7 : SIZEOF ( Generic_Deployment ) = 0;
	END_RULE;
END_SCHEMA;

SCHEMA Pip_No_Deadlock_constraint;
	USE FROM Resources;
	USE FROM Dependencies;

	RULE Pip_No_Deadlock FOR ( Generic_Resource, Resource_Dependency_Type );
	WHERE
		R13 : ( SIZEOF ( QUERY ( r <* Generic_Resource |
					 ( ( r.protocol = Priority_Inheritance_Protocol ) AND
						 ( SIZEOF ( QUERY ( d <* Resource_Dependency_Type |
									 d.resource_dependency_resource =
									 r ) ) <
							 2 ) ) ) ) =
			 0 ) AND
		 ( SIZEOF ( QUERY ( d <* Dependency |
					 d.discriminant <> Resource_Dependency_Type ) ) = 0 );
	END_RULE;
END_SCHEMA;

SCHEMA At_least_One_Blackboard_constraint;
	USE FROM Dependencies;

	RULE At_least_One_Blackboard FOR ( Black_board_Buffer_Dependency_Type );
	WHERE
		R13 : SIZEOF ( Black_board_Buffer_Dependency_Type ) > 1;
	END_RULE;
END_SCHEMA;