Adapter Pattern

• We use a example case, drawiing geometric shape.

    struct Point
    {
      int x, y;
    };
  
    struct Line{
      Point start, end;
    };
  
    struct VectorObject
    {
      virtual std::vector<Line>::iterator begin() = 0;
      virtual std::vector<Line>::iterator end() = 0;
    };
  
    struct VectorRectangle : VectorObject
    {
      VectorRectangle(int x, int y, int width, int height)
      {
        lines.emplace_back(Line{ Point{x, y}, Point{x + width, y} });
        lines.emplace_back(Line{ Point{x + width, y}, Point {x + width, y + height} });
        lines.emplace_back(Line{ Point{x,y}, Point{x, y + height} });
        lines.emplace_back(Line{ Point{ x, y + height }, Point {x + width, y + height} });
      }
  
      std::vecotr<Line>::iterator begin() override {
        return lines.begin();
      }
      std::vector<Line>::iterator end() override {
        return lines.end();
      }
  
    private:
      std::vector<Line> lines;
    };
  
    void DrawPoints(CPaintDC& dc,
      std::vector<Point>::iterator start,
      std::vector<Point>::iterator end)
    {
      for (auto i = start; i != end; ++i)
        dc.SetPixel(i->x, i->y , 0);
    }
  

Adapter

• Let’s draw a few rectangles.

    vector<shared_ptr<VectorObject>> vectorObjects{
      make_shared<VectorRectangle>(10, 10, 100, 100),
      make_shared<VectorRectangle>(30, 30, 60, 60)
    }

    struct LineToPointAdapter
    {
      typedef vector<Point> Points;

      LineToPointAdapter(Line& line);

      virtual Points::iterator begin() { return points.begin(); }
      virtual Points::iterator end() { return points.end(); }
    private:
      Points points;
    };

    LineToPointAdapter::LineToPointAdapter(Line& line)
    {
      int left = min(line.start.x, line.end.x);
      int right = max(line.start.x, line.end.x);
      int top = min(line.start.y, line.end.y);
      int bottom = max(line.start.y, line.end.y);
      int dx = right - left;
      int dy = line.end.y - line.start.y;

      if (dx == 0)
      {
        for (int y = top; y <= bottom; ++y)
        {
          points.emplace_back(Point{ left, y });
        }
      }
      else if (dy == 0)
      {
        for (int x = left; x <= right; ++x)
        {
          points.emplace_back(Point{ x, top });
        }
      }
    }


    for (auto& obj : vectorObjects)
    {
      for (auto& line : *obj)
      {
        LineToPointAdapter lpo{ line };
        DrawPoints(dc, lpo.begin(), lpo.end());
      }
    }

Temporary Adapter

• How about above method is called in every display update despite no change?

  • One of the solutions is to use cache.

      vector<Point> points;
      for (auto& o : vectorObjects)
      {
        for (auto& l : *o)
        {
          LineToPointAdapter lpo{ l };
          for (auto& p : lp)
            points.push_back(p);
        }
      }
    

  • Of course, this solution cause another problem. That is original vectorOjbects is changed.

      struct Point
      {
        int x, y;
        friend std:: size_t hash_value(const POint& obj)
        {
          std::size_t send = 0x825C696F;
          boost::hash_combine(seed, obj.x);
          boost::hash_combine(seed, obj.y);
          return seed;
        }
      };
    
      struct Line
      {
        Point start, end;
        friend std::size_t hash_value(const Line& obj)
        {
          std::size_t seed = 0x719E6B16;
          boost::hash_combine(seed, obj.start);
          boost::hash_combine(seed, obj.end);
          return seed;
        }
      };
    
      static map<size_t, Points> cache;
    
      virtual Points::iterator begin() { return cache[line_hash].begin(); }
      virtual Points::iterator end() { return cache[line_hash].end(); }
    
      LineToPointCachingAdapter(Line& line){
        static boost::hash<Line> hash;
        line_hash = hash(line);
        if (cache.find(line_hash) != cache.end())
          return;
    
        Points points;
    
        /* before code */
        /* remove before cached point */
        cache[line_hash] = points;
      }