cs_int_pairs_to_points_map.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */ 

#ifndef CS_INT_PAIRS_TO_POINTS_MAP_HPP
#define CS_INT_PAIRS_TO_POINTS_MAP_HPP

#include "cs_sfileinst_decl.hpp"
#include "cs_int_pair_set.h"
#include "cs_point_set_decl.hpp"

namespace cs{

    class int_pairs_to_points_map{
        int_pairs_to_points_map();
        /* Sorry, copy construction not implemented. */
        int_pairs_to_points_map(const int_pairs_to_points_map &);
        cs_ips_to_pdgvs_map inner;
    public:


        int_pairs_to_points_map(sfileinst sfi)
        { check(cs_ips_to_pdgvs_map_open(cglue<sfileinst>::unwrap(sfi), &inner)); }
        ~int_pairs_to_points_map()
        { check(cs_ips_to_pdgvs_map_close(inner)); }
        
        CS_BOILERPLATE_HASH_TYPE hash() const
        { return cs_ips_to_pdgvs_map_hash(inner); }
        

        point_set operator[](int_pair i) const
        {
            cs_pdg_vertex_set rv;
            check(cs_ips_to_pdgvs_map_lookup(inner, i.first, i.second, &rv));
            return cglue<point_set>::wrap(rv, false);
        }

#if defined(SWIG) && defined(SWIGPYTHON)
        %rename(__contains__) contains;
#endif

        bool contains(int_pair i) const
        {
            cs_pdg_vertex_set rv;
            cs_result r = cs_ips_to_pdgvs_map_lookup(
                inner, i.first, 
                i.second, &rv);
            switch( r )
            {
            case CS_SUCCESS:
            {
                bool is_empty = !!cs_pdg_vertex_set_empty(rv);
                cs_pdg_vertex_set_close(rv);
                return !is_empty;
            }
            default:
                check(r);
                return false;
            }
        }

#if defined(SWIG) && defined(SWIGPYTHON)
        %pythoncode{
            def __getitem__(self, k):
                try:
                    return self._getitem_impl(k)
                except result as r:
                    if r == result.ELEMENT_NOT_PRESENT:
                        raise KeyError(k)
                    raise
            def get(self, k, dflt=None):
                try:
                    return self._getitem_impl(k)
                except result as r:
                    if r == result.ELEMENT_NOT_PRESENT:
                        return dflt
                    raise
        };
#endif
        
        std::string as_repr() const
        { return CS_AS_REPR(int_pairs_to_points_map, std::string("...")); }
        
        std::string as_string() const
        { return as_repr(); }
        
#ifdef SWIG_BUILD

        bool operator==(const int_pairs_to_points_map& b) const
        {
            return !!cs_ips_to_pdgvs_map_same_instance(
                inner, b.inner); 
        }
        
        bool operator!=(const int_pairs_to_points_map& b) const
        { return !(*this == b); }
#else

        friend bool operator==(const int_pairs_to_points_map& a, 
                               const int_pairs_to_points_map& b);
#endif
    };
    inline std::ostream &operator<<( std::ostream &out, 
                                     const int_pairs_to_points_map &a )
    { return out << a.as_repr(); }

#ifndef SWIG_BUILD

    inline bool operator==(const int_pairs_to_points_map& a, 
                           const int_pairs_to_points_map& b)
    {
        return !!cs_ips_to_pdgvs_map_same_instance(
            a.inner, b.inner); 
    }

    inline bool operator!=(const int_pairs_to_points_map& a, 
                           const int_pairs_to_points_map& b)
    { return !(a == b); }
#endif

}

#endif /* CS_INT_PAIRS_TO_POINTS_MAP_HPP */