Ignore:
Timestamp:
Jun 26, 2015, 3:27:40 PM (4 years ago)
Author:
nmedfort
Message:

More modifications to UnicodeSet? class.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/UCD/unicode_set.h

    r4617 r4618  
    3030//
    3131
     32namespace llvm {
     33class raw_ostream;
     34}
     35
    3236typedef uint32_t bitquad_t;
    3337
     
    4246
    4347class UnicodeSet;
    44 
     48    using codepoint_t = re::codepoint_t;
     49    using interval_t = re::interval_t;
     50    using RunVector = std::vector<RunStructure>;
     51    using QuadVector = std::vector<bitquad_t>;
    4552class UnicodeSet {
    4653public:
    47 
    48     class quad_iterator : public boost::iterator_facade<quad_iterator, const std::pair<RunStructure, bitquad_t>, boost::forward_traversal_tag> {
    49         friend class UnicodeSet;
    50         friend class boost::iterator_core_access;
    51     protected:
    52         quad_iterator(const UnicodeSet & set, unsigned runIndex) : mUnicodeSet(set), mRunIndex(runIndex), mOffset(0), mQuadIndex(0) {}
    53 
    54         void advance(unsigned n);
    55 
    56         const std::pair<RunStructure, bitquad_t> dereference() const;
    57 
    58         inline void increment() {
    59             advance(1);
    60         }
    61 
    62         inline bool equal(quad_iterator const& other) const {
    63             assert (&(mUnicodeSet) == &(other.mUnicodeSet));
    64             return (mRunIndex == other.mRunIndex) && (mQuadIndex == other.mQuadIndex) && (mOffset == other.mOffset);
    65         }
    66     private:
    67         const UnicodeSet &          mUnicodeSet;
    68         unsigned                    mRunIndex;
    69         unsigned                    mOffset;
    70         unsigned                    mQuadIndex;
    71     };
    7254
    7355    class iterator : public boost::iterator_facade<iterator, re::interval_t, boost::forward_traversal_tag, re::interval_t> {
     
    7557        friend class boost::iterator_core_access;
    7658    protected:
    77         iterator(const UnicodeSet & set, unsigned runIndex, unsigned quadIndex)
    78         : mUnicodeSet(set), mRunIndex(runIndex), mQuadIndex(quadIndex), mQuadOffset(0)
    79         , mQuadRunIndex(0), mBaseCodePoint(0), mLeft(0), mRight(0)
     59        iterator(RunVector::const_iterator runIterator, QuadVector::const_iterator quadIterator)
     60        : mRunIterator(runIterator), mQuadIterator(quadIterator), mQuadOffset(0)
     61        , mQuadPosition(0), mBaseCodePoint(0), mMinCodePoint(0), mMaxCodePoint(0)
    8062        {
    8163
     
    8567
    8668        re::interval_t dereference() const {
    87             return std::make_pair(mLeft, mRight);
     69            return std::make_pair(mMinCodePoint, mMaxCodePoint);
    8870        }
    8971
     
    9476        inline bool equal(iterator const & other) const {
    9577            assert (&(mUnicodeSet) == &(other.mUnicodeSet));
    96             return (mRunIndex == other.mRunIndex) && (mQuadIndex == other.mQuadIndex) &&
    97                    (mQuadOffset == other.mQuadOffset) && (mQuadRunIndex == other.mQuadRunIndex);
     78            return (mRunIterator == other.mRunIterator) && (mQuadIterator == other.mQuadIterator);
    9879        }
    9980    private:
    100         const UnicodeSet &      mUnicodeSet;
    101         unsigned                mRunIndex;
    102         unsigned                mQuadIndex;
    103         bitquad_t               mQuadOffset;
    104         unsigned                mQuadRunIndex;
    105         unsigned                mBaseCodePoint;
    106         re::codepoint_t         mLeft;
    107         re::codepoint_t         mRight;
     81        RunVector::const_iterator   mRunIterator;
     82        QuadVector::const_iterator  mQuadIterator;
     83        bitquad_t                   mQuadOffset;
     84        unsigned                    mQuadPosition;
     85        unsigned                    mBaseCodePoint;
     86        re::codepoint_t             mMinCodePoint;
     87        re::codepoint_t             mMaxCodePoint;
     88    };
     89
     90    inline iterator begin() const {
     91        return iterator(runs.cbegin(), quads.cbegin());
     92    }
     93
     94    inline iterator end() const {
     95        return iterator(runs.cend(), quads.cend());
     96    }
     97
     98    bool contains(const codepoint_t codepoint) const;
     99
     100    void dump(llvm::raw_ostream & out) const;
     101
     102    UnicodeSet complement() const;
     103    UnicodeSet operator & (const UnicodeSet & other) const;
     104    UnicodeSet operator + (const UnicodeSet & other) const;
     105    UnicodeSet operator - (const UnicodeSet & other) const;
     106    UnicodeSet operator ^ (const UnicodeSet & other) const;
     107
     108    UnicodeSet();
     109    UnicodeSet(const codepoint_t codepoint);
     110    UnicodeSet(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint);
     111    UnicodeSet(std::initializer_list<RunStructure> r, std::initializer_list<bitquad_t> q) : runs(r), quads(q) {}
     112
     113protected:
     114
     115    class quad_iterator : public boost::iterator_facade<quad_iterator, std::pair<RunStructure, bitquad_t>, boost::random_access_traversal_tag> {
     116        friend class UnicodeSet;
     117        friend class boost::iterator_core_access;
     118    public:
     119        quad_iterator(const UnicodeSet & set, unsigned runIndex) : mUnicodeSet(set), mRunIndex(runIndex), mOffset(0), mQuadIndex(0) {}
     120
     121        void advance(unsigned n);
     122
     123        inline const std::pair<RunStructure, bitquad_t> dereference() const {
     124            return std::make_pair(getRun(), getQuad());
     125        }
     126
     127        inline void increment() {
     128            advance(1);
     129        }
     130
     131        inline RunStructure getRun() const {
     132            const auto & t = mUnicodeSet.runs[mRunIndex];
     133            return RunStructure(t.mType, t.mRunLength - mOffset);
     134        }
     135
     136        inline bitquad_t getQuad() const {
     137            return mUnicodeSet.quads[mQuadIndex];
     138        }
     139
     140        inline bool equal(const quad_iterator & other) const {
     141            assert (&(mUnicodeSet) == &(other.mUnicodeSet));
     142            return (mRunIndex == other.mRunIndex);
     143        }
     144
     145    private:
     146        const UnicodeSet &          mUnicodeSet;
     147        unsigned                    mRunIndex;
     148        unsigned                    mOffset;
     149        unsigned                    mQuadIndex;
    108150    };
    109151
     
    116158    }
    117159
    118     inline iterator begin() const {
    119         return iterator(*this, 0,0);
    120     }
     160    friend class UnicodeSet::quad_iterator;
    121161
    122     inline iterator end() const {
    123         return iterator(*this, runs.size(), quads.size());
    124     }
     162    // Internal helper functions
     163    void append_run(const run_type_t type, const unsigned length);
     164    void append_quad(const bitquad_t quad);
    125165
    126 //
    127 //  The internal fields for a UnicodeSet.
     166private:
     167
     168    // The internal fields for a UnicodeSet.
    128169    std::vector<RunStructure>   runs;
    129170    std::vector<bitquad_t>      quads;
    130     unsigned quad_count;
    131171   
    132 // 
    133 //  Internal helper functions
    134     void append_run(run_type_t run_type, int run_length);
    135     void append_quad(bitquad_t q);
    136 //
    137 //  Nullary constructor for incremental building.
    138     UnicodeSet() : quad_count(0) {}
    139 //
    140 //  Ternary constructor for constant construction using precomputed data.
    141     UnicodeSet(std::initializer_list<RunStructure> r, std::initializer_list<bitquad_t> q, unsigned c) : runs(r), quads(q), quad_count(c) {}
     172
    142173};
    143174
    144 void Dump_uset(UnicodeSet s);
    145 UnicodeSet empty_uset();
    146 UnicodeSet singleton_uset(int codepoint);
    147 UnicodeSet range_uset(int lo_codepoint, int hi_codepoint);
    148 UnicodeSet uset_complement (const UnicodeSet &s);
    149 UnicodeSet uset_union(const UnicodeSet & s1, const UnicodeSet & s2);
    150 UnicodeSet uset_intersection(const UnicodeSet &s1, const UnicodeSet &s2);
    151 UnicodeSet uset_difference(const UnicodeSet &s1, const UnicodeSet &s2);
    152 UnicodeSet uset_symmetric_difference(const UnicodeSet & s1, const UnicodeSet & s2);
    153 bool uset_member(const UnicodeSet & s, int codepoint);
     175inline UnicodeSet uset_complement(const UnicodeSet & s) {
     176    return s.complement();
     177}
     178
     179inline UnicodeSet uset_intersection(const UnicodeSet & s1, const UnicodeSet & s2) {
     180    return s1 & s2;
     181}
     182
     183inline UnicodeSet uset_union(const UnicodeSet & s1, const UnicodeSet & s2) {
     184    return s1 + s2;
     185}
     186
     187inline UnicodeSet uset_difference(const UnicodeSet & s1, const UnicodeSet & s2) {
     188    return s1 - s2;
     189}
     190
     191inline UnicodeSet uset_symmetric_difference(const UnicodeSet & s1, const UnicodeSet & s2) {
     192    return s1 ^ s2;
     193}
    154194
    155195#endif
Note: See TracChangeset for help on using the changeset viewer.