.. _program_listing_file_src_graspi_predicates.hpp:

Program Listing for File graspi_predicates.hpp
==============================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_graspi_predicates.hpp>` (``src/graspi_predicates.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /***
    *  $Id$
    **
    *  File: graspi_predicates.hpp
    *  Created: May 9, 2012
    *
    *  Author: Olga Wodo, Baskar Ganapathysubramanian
    *  Copyright (c) 2012 Olga Wodo, Baskar Ganapthysubramanian
    *  See accompanying LICENSE.
    *
    *  This file is part of GraSPI.
    */
   
   #ifndef GRASPI_PREDICATES_HPP
   #define GRASPI_PREDICATES_HPP
   
   #include "graspi_types.hpp"
   #include "graspi_cc.hpp"
   
   namespace graspi{
   
       class connect_same_color {
       public:
           connect_same_color() : G_(0), vertex_colors_(0) { }
   
           connect_same_color(const graspi::graph_t& G,
                              const graspi::vertex_colors_t& vertex_colors)
           : G_(&G), vertex_colors_(&vertex_colors){ }
   
           bool operator()(const graspi::edge_descriptor_t& e) const {
   
               return
               ( (*vertex_colors_)[boost::source(e, *G_)]
                ==
                (*vertex_colors_)[boost::target(e, *G_)]
                );
           }
   
       private:
           const graspi::graph_t* G_;  
           const graspi::vertex_colors_t* vertex_colors_; 
       }; // class connect_same_color
   
       class connect_color_green {
       public:
           connect_color_green() : G_(0), vertex_colors_(0) { }
   
           connect_color_green(const graph_t& G,
                               const vertex_colors_t& C,
                               COLOR color, COLOR green = GREEN)
           : green_(green), color_(color), G_(&G), vertex_colors_(&C)  { }
   
           bool operator()(const edge_descriptor_t& e) const {
               if ( ( ( (*vertex_colors_)[boost::source(e, *G_)] == green_ )
                     && ( (*vertex_colors_)[boost::target(e, *G_)] == color_ ) )
                   ||
                   ( ( (*vertex_colors_)[boost::target(e, *G_)] == green_ )
                    && ( (*vertex_colors_)[boost::source(e, *G_)] == color_ ) )
                   )
                   return true;
               return (
                       (*vertex_colors_)[boost::source(e, *G_)]
                       ==
                       (*vertex_colors_)[boost::target(e, *G_)]
                       );
           }
   
       private:
           COLOR green_;  
           COLOR color_; 
           const graph_t* G_; 
           const vertex_colors_t* vertex_colors_; 
       }; // class connect_black_green
   
   
   
       class connect_same_color_and_relevant_meta_vertex {
       public:
           connect_same_color_and_relevant_meta_vertex ()
           : G_(0), vertex_colors_(0) { }
   
           connect_same_color_and_relevant_meta_vertex (const graph_t& G,
                                                        const vertex_colors_t& C)
           : G_(&G), vertex_colors_(&C) { }
   
           bool operator()(const edge_descriptor_t& e) const {
               if ( ((*vertex_colors_)[boost::source(e, *G_)]
                     +
                     (*vertex_colors_)[boost::target(e, *G_)]  )
                   == 20) return true; //black+red
               if ( ((*vertex_colors_)[boost::source(e, *G_)]
                     +
                     (*vertex_colors_)[boost::target(e, *G_)]  )
                   == 11) return true; //white+blue
               if ( ((*vertex_colors_)[boost::source(e, *G_)]
                     +
                     (*vertex_colors_)[boost::target(e, *G_)]  )
                   == 23) return true; //grey+red
               if ( ((*vertex_colors_)[boost::source(e, *G_)]
                     +
                     (*vertex_colors_)[boost::target(e, *G_)]  )
                   == 13) return true; //grey+blue
   
               return ((*vertex_colors_)[boost::source(e, *G_)]
                       ==
                       (*vertex_colors_)[boost::target(e, *G_)]);
           }
   
       private:
           const graph_t* G_;  
           const vertex_colors_t* vertex_colors_; 
       }; // class connect_same_color_and_relevant_meta_vertex
   
       class connect_relevant_meta_vertex {
       public:
           connect_relevant_meta_vertex()
           : G_(0), vertex_colors_(0), vertex_ccs_(0), ccs_(0), c_(0) { }
           void change_color(COLOR c){ c_ = c; }
   
           connect_relevant_meta_vertex(const graph_t& G,
                                        const vertex_colors_t& C,
                                        const vertex_ccs_t& vCC,
                                        const ccs_t& CC,
                                        COLOR color)
           : G_(&G), vertex_colors_(&C), vertex_ccs_(&vCC),
           ccs_(&CC), c_(color) { }
   
           bool operator()(const vertex_t& vertex_id) const {
               if( (*vertex_colors_)[vertex_id] != c_) return false;
   
               if (
                   ( c_ == BLACK ) &&
                   ( (*ccs_)[(*vertex_ccs_)[vertex_id]].if_connected_to_top() )
                   ) return true;
               if (
                   ( c_ == WHITE ) &&
                   ( (*ccs_)[(*vertex_ccs_)[vertex_id]].if_connected_to_bottom() )
                   ) return true;
               return false;
           }
       private:
           const graph_t* G_;  
           const vertex_colors_t* vertex_colors_; 
           const vertex_ccs_t* vertex_ccs_; 
           const ccs_t* ccs_; 
           COLOR c_; 
       }; // connect_relevant_meta_vertex
   
   
       // Predicate used to identify descriptor of a given name
       class find_desc_of_name {
       public:
           find_desc_of_name():desc_(" "){}
   
           find_desc_of_name(const std::string desc_name)
           : desc_(desc_name){ }
   
           void set_desc(const std::string& desc){desc_=desc;}
   
           bool operator()(const std::pair<float,std::string>& p_desc) const {
               return p_desc.second == desc_;
           }
   
       private:
           std::string desc_;
       }; // class find_desc_of_name
   
   }//graspi-namespace
   
   #endif