/**
 * Module containing the signature and utility-strategies
 * for inclusion-id's
 */
module php/reflect/inclusion/inclusionid
signature
  constructors
    Inclusionid : String * String -> Inclusionid  //for the annotation of terms  InclusionId(Path,ID)

    Inclusionstatus : InclusionMode -> InclusionStatus // For status of inclusion
    
    MaybeIncluded : InclusionMode
    DefIncluded   : InclusionMode
    NotIncluded   : InclusionMode

 
strategies
  /**
   * Generates an unique id for inclusion
   *
   * @type Path -> Inclusionid
   */
  new-inclusion-id =
     ?path
   ; !"inclusion"
   ; newname => iid
   ; !Inclusionid(path,iid)

  /**
   * Adds an inclusion id to a term.
   * The inclusion id is always unique.
   *
   * @param id Inclusionid representing the ID
   * @type Term -> Term
   */
   add-inclusion-id(|iid) =
       ?t{a*}
     ; a' := <remove-all(?Inclusionid(_,_))> a*
     ; annos* := [ iid | a']
     ; !t{annos*}

  /**
   * Gets an inclusion id from a term.
   *
   * @type Term -> Inclusionid
   */
   get-inclusion-id =
       ?t{a*}
     ; <fetch-elem(?Inclusionid(_,_))> a*

rules
  /**
   * Merge rules for InclusionStatus
   */
  inclusion-combine-unit: (NotIncluded(),NotIncluded()) -> NotIncluded()         
  inclusion-combine-unit: (NotIncluded(),x)             -> MaybeIncluded()         
    where <not(?NotIncluded())> x
  inclusion-combine-unit: (MaybeIncluded(),_)           -> MaybeIncluded()         
  inclusion-combine-unit: (_,MaybeIncluded())           -> MaybeIncluded()         
  inclusion-combine-unit: (DefIncluded(),DefIncluded()) -> DefIncluded()
  
strategies
  /**
   * Get the inclusion status of a certain file
   * @type String -> InclusionStatus
   */  
  get-inclusion-status = 
     EvalInclusionStatus 
  <+ !NotIncluded()
  
  /**
   * Add included status to a filepath.
   * Relies on the value set in the dynamic rule 
   * InclusionMode to set the mode. If this rule is not set it uses
   * the default DefIncluded()
   *
   * @type String -> String
   */
  add-inclusion-status = 
     ?t 
   ; (InclusionMode <+ !DefIncluded()) ; ?stat
   ; rules(EvalInclusionStatus: t -> stat)
 
  /**
   * Redefines the status of a inclusion
   * @type (file,stat) -> (file,stat)
   */ 
  redefine-inclusion-status = 
     ?(path,stat)
   ; rules(EvalInclusionStatus: path -> stat)

  /**
   * Runs a strategy while the InclusionMode is maybe.
   */
   maybe-inclusion-wrap(s) =
       {| InclusionMode :                                         
         rules(InclusionMode: _ -> MaybeIncluded())
        ; s 
       |}