void operator() (utree const& ut){
        
        using spirit::utree_type;
        typedef utree::const_iterator iterator;
        
        int id = cur_id;
        n_id++;
        
        switch (ut.which()) {
            case utree_type::reference_type:
                out << prefix << id << " [label=\"[reference]\"];\n"; 
                out << prefix << id << " -> " << prefix << cur_id << ";\n";
                (*this)(ut.deref());
                return;

            case utree_type::range_type:
            case utree_type::list_type:
            {    
                iterator it, end;
                
                int start_id = n_id;
                
                if (annotations[ut.tag()].second == json_object) {
                    out << prefix << id << " [label=\"[object]\"];\n"; 
                    it    = ut.front().begin();
                    end   = ut.front().end();
                    n_id += ut.front().size();
                } else {
                    if (annotations[ut.tag()].second == json_array) {
                        out << prefix << id << " [label=\"[array]\"];\n"; 
                    } else if (annotations[ut.tag()].second == json_pair) {
                        out << prefix << id << " [label=\"[pair]\"];\n"; 
                    } else {
                        BOOST_ASSERT(false);
                        return;
                    }
                    it    = ut.begin();
                    end   = ut.end();
                    n_id += ut.size();
                }
                
                for (int i=0; it != end; ++it, ++i) {
                    
                    cur_id = start_id+i; 
                    out << prefix << id << " -> " << prefix << cur_id << ";\n";
                    (*this)(*it);   
                }
                
                return;
            }    
            default:
                break;
        }

        utree::visit(ut, *this);
    }
示例#2
0
utree expression::fix_color_range(utree const& node) 
{
    BOOST_ASSERT(is_color(node) == TRUE);
    BOOST_ASSERT(node.size() == 4);

    typedef utree::const_iterator iter;
    
    utree ut;
    ut.tag(node.tag()); 
    for(iter it = node.begin(); it != node.end(); it++)
        ut.push_back( fmod(as<double>(*it), 256) );
    
    return ut;
}
示例#3
0
    void print_array (utree const& ut) const {
        typedef utree::const_iterator iterator;

        iterator it = ut.begin(), end = ut.end();

        (*this)('[');

        (*this)(*it); ++it;

        for (; it != end; ++it) {
            out << ", ";
            (*this)(*it);
        }

        (*this)(']');
    }
std::string filter_printer::operator() (utree const& ut)
{
    using spirit::utree_type;
    
    std::string out;
    
    if (ut.tag() == 0) {
        if (ut.which() == utree_type::list_type) {
            utree::const_iterator it = ut.begin(), end = ut.end();
            for (; it != end; ++it) 
                out += (*this)(*it);
        } else {
            out += as<std::string>(ut);
        }
        
        return out;
    }
    
    int const node_type = annotations[ut.tag()].second;
    
    typedef utree::const_iterator iter;
    iter it = ut.begin(),
        end = ut.end();
    
    if (node_type == filter_var || node_type == filter_var_attr) {
            
        utree value = parse_var(ut);
        
        if (node_type == filter_var_attr) 
            out += "[" + (*this)(value) + "]";
        else
            out += (*this)(value);
    } else if (node_type == filter_and) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it);
        
        if (a == "" || b == "")
            out += (a=="") ? a : b;
        else
            out += "(" + a + " and " + b + ")";

    } else if (node_type ==  filter_or) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it);
        
        if (a == "" || b == "")
            out += (a=="") ? a : b;
        else
            out += "(" + a + " or " + b + ")";
            
    } else if (node_type == filter_not) {
        BOOST_ASSERT(ut.size()==1);
        
        std::string a = (*this)(*it);
        
        if (a != "")
            out += "(not " + a + ")";
    } else if (node_type == filter_match) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it);
        
        out += a + ".match('" + b + "')";
        
    } else if (node_type == filter_replace) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it); it++;
        std::string c = (*this)(*it);
        
        out += a + ".replace('" + b + ", " + c + "')";
        
    } else if (node_type == filter_attribute) {
        //BOOST_ASSERT(ut.size()==1);
        out += "[" + (*this)(*it) + "]";
        
    } else if (node_type == filter_expression) {
        
    } else if (node_type == filter_eq) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_min_scale(zoom_ranges[b+1]);
            rule.set_max_scale(zoom_ranges[b]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type == filter_neq) {
        BOOST_ASSERT(ut.size()==2);

        std::string a = (*this)(*it); it++;

        if (a == "[zoom]") {
            std::string err = "Not equal is not currently supported for zoom levels (at "
                              + get_location(ut).get_string() + ")"; 
            throw config_error(err);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
    } else if (node_type ==  filter_le) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_min_scale(zoom_ranges[b]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type ==  filter_lt) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_min_scale(zoom_ranges[b-1]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type ==  filter_ge) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_max_scale(zoom_ranges[b]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type == filter_gt) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_max_scale(zoom_ranges[b+1]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    }
    
    return out;
}
    void operator() (utree const& ut){
        
        using spirit::utree_type;
        typedef utree::const_iterator iterator;
        
        int id = cur_id;
        n_id++;
        
        switch (ut.which()) {
            case utree_type::reference_type:
                out << prefix << id << " [label=\"[reference]\"];\n"; 
                out << prefix << id << " -> " << prefix << cur_id << ";\n";
                (*this)(ut.deref());
                return;

            case utree_type::range_type:
            case utree_type::list_type:
            {    
                iterator it, end;
                
                int start_id = n_id;
                carto_node_type nope_type = annotations[ut.tag()].second;

                /*if (annotations[ut.tag()].second == json_object) {
                    out << prefix << id << " [label=\"[object]\"];\n"; 
                    it    = ut.front().begin();
                    end   = ut.front().end();
                    n_id += ut.front().size();
                }*/
                
                out << prefix << id << " [label=\"[";
                switch(node_type) {
                    case CARTO_UNDEFINED:
                        out << "";
                        break;
                    case CARTO_VARIABLE:
                        out << "variable";
                        break;
                    case CARTO_MIXIN:
                        OUT << "mixin";
                        break;
                    case CARTO_STYLE:
                        out << "style";
                        break;
                    case CARTO_FUNCTION:
                        out << "function";
                        break;
                    case CARTO_ATTRIBUTE:
                        out << "attribute";
                        break;
                    case CARTO_COLOR:
                        out << "color";
                        break;
                    case CARTO_FILTER:
                        out << "filter";
                        break;
                    default:
                        std::cout << node_type << std::endl;
                        BOOST_ASSERT(false);
                        //return;
                }
                out << "]\"];\n";
                
                it    = ut.begin();
                end   = ut.end();
                n_id += ut.size();
                
                if (node_type == CARTO_FILTER) {
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i;
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                    
                        out << prefix << cur_id << " [label=\"";
                        generate_filter(*it,annotations,style_env(),out);
                        out << "\"];\n";
                    }
                    
                } else {                
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i; 
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                        (*this)(*it);   
                    }
                }
                
                return;
            }    
            default:
                break;
        }
        
        utree::visit(ut, *this);
    }
    void operator() (utree const& ut){
        
        using spirit::utree_type;
        typedef utree::const_iterator iterator;
        
        int id = cur_id;
        n_id++;
        
        switch (ut.which()) {
            case utree_type::reference_type:
                out << prefix << id << " [label=\"[reference]\"];\n"; 
                out << prefix << id << " -> " << prefix << cur_id << ";\n";
                (*this)(ut.deref());
                return;

            case utree_type::range_type:
            case utree_type::list_type:
            {    
                iterator it, end;
                
                int start_id = n_id;
                
                /*if (annotations[ut.tag()].second == json_object) {
                    out << prefix << id << " [label=\"[object]\"];\n"; 
                    it    = ut.front().begin();
                    end   = ut.front().end();
                    n_id += ut.front().size();
                }*/
                
                out << prefix << id << " [label=\"[";
                switch(annotations[ut.tag()].second) {
                    case carto_undefined:
                        out << "";
                        break;
                    case carto_variable:
                        out << "variable";
                        break;
                    case carto_mixin:
                        out << "mixin";
                        break;
                    case carto_style:
                        out << "style";
                        break;
                    case carto_function:
                        out << "function";
                        break;
                    case carto_attribute:
                        out << "attribute";
                        break;
                    case carto_color:
                        out << "color";
                        break;
                    case carto_filter:
                        out << "filter";
                        break;
                    default:
                        std::cout << annotations[ut.tag()].second << std::endl;
                        BOOST_ASSERT(false);
                        //return;
                }
                out << "]\"];\n";
                
                it    = ut.begin();
                end   = ut.end();
                n_id += ut.size();
                
                if (annotations[ut.tag()].second == carto_filter) {
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i;
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                    
                        out << prefix << cur_id << " [label=\"";
                        generate_filter(*it,annotations,style_env(),out);
                        out << "\"];\n";
                    }
                    
                } else {                
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i; 
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                        (*this)(*it);   
                    }
                }
                
                return;
            }    
            default:
                break;
        }
        
        utree::visit(ut, *this);
    }
示例#7
0
utree expression::eval_function(utree const& node)
{
    typedef utree::const_iterator iter;
    
    iter it  = node.begin(),
         end = node.end();
    
    std::string func_name = as<std::string>(*it);
    ++it;
    
    if (func_name == "test") {
        utree color = eval_node(*it); ++it;
        return test(color);
    } else if (func_name == "hue") {
        utree color = eval_node(*it); ++it;
        return hue(color);
    } else if (func_name == "saturation") {
        utree color = eval_node(*it); ++it;
        return saturation(color);
    } else if (func_name == "lightness") {
        utree color = eval_node(*it); ++it;
        return lightness(color);
    } else if (func_name == "alpha") {
        utree color = eval_node(*it); ++it;
        return alpha(color);
    } else if (func_name == "saturate") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return saturate(color,value);    
    } else if (func_name == "desaturate") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return desaturate(color,value);
    } else if (func_name == "lighten") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return lighten(color,value);
    } else if (func_name == "darken") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return darken(color,value);
    } else if (func_name == "fadein") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return fadein(color,value);
    } else if (func_name == "fadeout") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return fadeout(color,value);
    } else if (func_name == "spin") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return spin(color,value);
    } else if (func_name == "mix") {    
        utree color1 = eval_node(*it); ++it;
        utree color2 = eval_node(*it); ++it;
        utree weight = eval_node(*it); ++it;
        return mix(color1, color2, weight);
    } else if (func_name == "greyscale") {
        utree color = eval_node(*it); ++it;
        return greyscale(color);
    } else if (func_name == "url") {
        return eval_node(*it);
    } else {
        throw carto_error("Unknown function: " + func_name, get_location(node));
    }
}
示例#8
0
 void evaluateInstance(utree const &ast) {
   for ( utree::const_iterator it = ast.begin(), ie = ast.end();
         it != ie; ++it ) {
     evaluateCommand(*it);
   }
 }