property-set.jam

boost库提供标准的C++ API 配合dev c++使用,功能更加强大

#  Copyright (C) Vladimir Prus 2002. Permission to copy, use, modify, sell and
#  distribute this software is granted provided this copyright notice appears in
#  all copies. This software is provided "as is" without express or implied
#  warranty, and with no claim as to its suitability for any purpose.

import "class" : new ;
import feature ;
import property ;
import sequence ;

# Class for storing a set of properties.
# - there's 1<->1 correspondence between identity and value. No
#   two instances of the class are equal. To maintain this property,
#   the 'property-set.create' rule should be used to create new instances.
#   Instances are immutable.
# 
# - each property is classified as either base, free, dependency or incidental,
#   and it's possible to efficiently obtain properties of each class.
#
# - several operations, like and refine and as-path are provided. They all use
#   caching whenever possible.
#
class property-set 
{
    import feature ;
    import property-set ;
    import property ;
    import set ;
            
    rule __init__ ( raw-properties * )
    {        
        self.raw = $(raw-properties) ;
        
        for local p in $(raw-properties)
        {
            local att = [ feature.attributes $(p:G) ] ;        
            if incidental in $(att)
            {
                self.incidental += $(p) ;
            }
            else if free in $(att)
            {
                if dependency in $(att)
                {
                    self.dependency += $(p) ;
                }
                else
                {
                    self.free += $(p) ;
                }            
            }
            else 
            {
                self.base += $(p) ;
            }
            
            if propagated in $(att)
            {
                self.propagated += $(p) ;
            }                        
            if link-incompatible in $(att)
            {
                self.link-incompatible += $(p) ;
            }                                
        }
    }
    
    
    # Returns Jam list of stored properties
    rule raw ( )
    {
        return $(self.raw) ;
    }
    
    # Returns properties that are neither incidental nor free
    rule base ( )
    {
        return $(self.base) ;
    }
    
    
    # Returns free properties which are not dependency properties
    rule free ( )
    {
        return $(self.free) ;
    }
    
    # Returns dependency properties
    rule dependency ( )
    {
        return $(self.dependency) ;
    }
    
    # Returns incidental properties
    rule incidental ( )
    {
        return $(self.incidental) ;
    }
    
    rule refine ( ps )
    {
        if ! $(self.refined.$(ps))
        {
            local r = [ property.refine $(self.raw) : [ $(ps).raw ] ] ; 
            if $(r[1]) != "@error"
            {
                self.refined.$(ps) = [ property-set.create $(r) ] ; 
            }
            else
            {
                self.refined.$(ps) = $(r) ;
            }
        }
        return $(self.refined.$(ps)) ;
    }
    
    rule expand-composites ( )
    {
        if ! $(self.composites)
        {
            self.composites = [ property-set.create
                [ feature.expand-composites $(self.raw) ] ] ;
        }
        return $(self.composites) ;
    }
                
    rule evaluate-conditionals ( context ? )
    {
        context ?= $(__name__) ;
        if ! $(self.evaluated.$(context))
        {
            self.evaluated.$(context) = [ property-set.create 
                [ property.evaluate-conditionals-in-context $(self.raw) : [ $(context).raw ] ] ] ;
        }
        return $(self.evaluated.$(context)) ;        
    }
    
    rule propagated ( )
    {
        if ! $(self.propagated-ps)
        {
            self.propagated-ps = [ property-set.create $(self.propagated) ] ;
        }
        return $(self.propagated-ps) ;
    }                   
    
    rule link-incompatible ( )
    {
        if ! $(self.link-incompatible-ps)
        {
            self.link-incompatible-ps = 
              [ property-set.create $(self.link-incompatible) ] ;
        }
        return $(self.link-incompatible-ps) ;
    }
    
    
    rule run-actions ( )
    {
        if ! $(self.run)
        {
            self.run = [ property-set.create [ feature.run-actions $(self.raw) ] ] ;
        }
        return $(self.run) ;
    }
    
    rule add-defaults ( )
    {
        if ! $(self.defaults)
        {
            self.defaults = [ property-set.create 
                [ feature.add-defaults $(self.raw) ] ] ;
        }
        return $(self.defaults) ;
    }
    
    
    rule as-path ( )
    {
        if ! $(self.as-path)
        {
            self.as-path = [ property.as-path $(self.base) ] ;
        }        
        return $(self.as-path) ;
    }        
    
    rule add ( ps )
    {
        if ! $(self.added.$(ps))        
        {
            self.added.$(ps) = [ property-set.create $(self.raw) [ $(ps).raw ] ] ;
        }
        return $(self.added.$(ps)) ;
    }            
    
    rule add-raw ( properties * )
    {
        return [ add [ property-set.create $(properties) ] ] ;
    }            
    
    rule link-incompatible-with ( ps )
    {
        if ! $(.li.$(ps))
        {
            local li1 = [ $(__name__).link-incompatible ] ;
            local li2 = [ $(ps).link-incompatible ] ;            
            if [ set.equal $(li1) : $(li2) ] 
            {
                .li.$(ps) = false ;
            }
            else
            {
                .li.$(ps) = true ;
            }            
        }    
        if $(.li.$(ps)) = true
        {
            return true ;
        }
        else
        {
            return ;
        }                
    }
    

    
    # Returns all values of 'feature'.
    rule get ( feature )
    {
        return [ feature.get-values $(feature) : $(self.raw) ] ;
    }
    
}

# Creates new 'property-set' instance for the given raw properties,
# or returns an already existing ones.
rule create ( raw-properties * )
{
    raw-properties = [ sequence.unique 
        [ sequence.insertion-sort $(raw-properties) ] ] ;
         
    local key = $(raw-properties:J=-:E=) ;
    
    if ! $(.ps.$(key)) 
    {
        .ps.$(key) = [ new property-set $(raw-properties) ] ;
    }
    return $(.ps.$(key)) ;    
}
NATIVE_RULE property-set : create ;

# Creates new 'property-set' instances after checking
# that all properties are valid and converting incidental
# properties into gristed form.
rule create-with-validation ( raw-properties * )
{
    property.validate $(raw-properties) ;
    
    return [ create [ property.make $(raw-properties) ] ] ;
}


# Returns property-set with empty set of properties.
rule empty ( )
{
    if ! $(.empty)
    {
      .empty = [ create ] ;
    }
    
    return $(.empty) ;
}