these are the initial repos that are to be loaded to the github java repository

Author: AloyASen

changelog.md

@@ -0,0 +1,16 @@
+### why are you here?
+
+this page was added on 2 01 2018 so wishing everyone a good luck . we are hosting the rough codes that we have been doing through the days and still keeping up to the cycle of newer horizons in th e near future we dream big so we expect you to do so with us 
+
+###what will i get here ?
+
+these are the data- structures and programs developed by the use of famous libraries of the time which have been tested over time to be error free and the best part is they are free to use.
+
+###what are the libraries used ??
+
+these codes have used several of the standard libraries , gnu scientific library , poco native libraries , boost static headers and  also uses the dynamic libraries provided by them . there is also use of the proven datastructures as listed by the libraries themselves 
+
+##how to go about ??
+
+ every folder that has some code in it , has a modify.md file on for the convenience of tracking contributions and timeline ... if you find something fishy do report us at issues of this git repository we would get back to you as soon as possible and maybe resolve your issues over a cup of coffee
+ 

design patterns/structural pattern/adapter pattern/adapter_pattern

@@ -0,0 +1,61 @@
+#include <iostream>
+
+typedef int Coordinate;
+typedef int Dimension;
+
+// Desired interface
+
+using namespace std;
+class Rectangle
+{
+  public:
+    virtual void draw() = 0;
+};
+
+// Legacy component
+class LegacyRectangle
+{
+  public:
+    LegacyRectangle(Coordinate x1, Coordinate y1, Coordinate x2, Coordinate y2)
+    {
+        x1_ = x1;
+        y1_ = y1;
+        x2_ = x2;
+        y2_ = y2;
+        cout << "LegacyRectangle:  create.  (" << x1_ << "," << y1_ << ") => ("
+          << x2_ << "," << y2_ << ")" << endl;
+    }
+    void oldDraw()
+    {
+        cout << "LegacyRectangle:  oldDraw.  (" << x1_ << "," << y1_ << 
+          ") => (" << x2_ << "," << y2_ << ")" << endl;
+    }
+  private:
+    Coordinate x1_;
+    Coordinate y1_;
+    Coordinate x2_;
+    Coordinate y2_;
+};
+
+// Adapter wrapper
+class RectangleAdapter: public Rectangle, private LegacyRectangle
+{
+  public:
+    RectangleAdapter(Coordinate x, Coordinate y, Dimension w, Dimension h):
+      LegacyRectangle(x, y, x + w, y + h)
+    {
+        cout << "RectangleAdapter: create.  (" << x << "," << y << 
+          "), width = " << w << ", height = " << h << endl;
+    }
+    virtual void draw()
+    {
+        cout << "RectangleAdapter: draw." << endl;
+        oldDraw();
+    }
+};
+
+int main()
+{
+  Rectangle *r = new RectangleAdapter(120, 200, 60, 40);
+  r->draw();
+}

design patterns/structural pattern/adapter pattern/adapter_pattern.cc

@@ -0,0 +1,42 @@
+this is the first design pattern ever implemented by a cs coder 
+
+remember the adapter pattern can only be implemented when multiple inheritance is allowed 
+
+the class is to get the correct data interface between existing and new code as a adapter between the informations to be exchanged.
+
+output:: 
+---------
+
+LegacyRectangle:  create.  (120,200) => (180,240)
+RectangleAdapter: create.  (120,200), width = 60, height = 40
+RectangleAdapter: draw.
+LegacyRectangle:  oldDraw.  (120,200) => (180,240)
+
+
+
+the pages that are best suited for learning
+
+refactoring.guru
+
+sourcemaking.com
+
+
+downside 
+---------
+
+Increases overall code complexity by creating additional classes.
+
+
+
+Bridge is designed up-front to let the abstraction and the implementation vary independently. Adapter is retrofitted to make unrelated classes work together. Adapter makes things work after they're designed; Bridge makes them work before they are.
+
+
+Adapter provides a different interface to its subject. Proxy provides the same interface. Decorator provides an enhanced interface.
+
+
+Adapter is meant to change the interface of an existing object. Decorator enhances another object without changing its interface. Decorator is thus more transparent to the application than an adapter is. As a consequence, Decorator supports recursive composition, which isn't possible with pure Adapters.
+
+
+Facade defines a new interface, whereas Adapter reuses an old interface. Remember that Adapter makes two existing interfaces work together as opposed to defining an entirely new one.
+
+State, Strategy, Bridge (and to some degree Adapter) have similar solution structures. They all share elements of the "handle/body" idiom. They differ in intent - that is, they solve different problems.

design patterns/structural pattern/adapter pattern/modify.md

@@ -0,0 +1,88 @@
+#include <iostream>
+#include <iomanip>
+#include <string>
+
+using namespace std;
+class TimeImp {
+  public:
+    TimeImp(int hr, int min) {
+        hr_ = hr;
+        min_ = min;
+    }
+    virtual void tell() {
+        cout << "time is " << setw(2) << setfill(48) << hr_ << min_ << endl;
+    }
+  protected:
+    int hr_, min_;
+};
+
+class CivilianTimeImp: public TimeImp {
+  public:
+    CivilianTimeImp(int hr, int min, int pm): TimeImp(hr, min) {
+        if (pm)
+          strcpy(whichM_, " PM");
+        else
+          strcpy(whichM_, " AM");
+    }
+
+    /* virtual */
+    void tell() {
+        cout << "time is " << hr_ << ":" << min_ << whichM_ << endl;
+    }
+  protected:
+    char whichM_[4];
+};
+
+class ZuluTimeImp: public TimeImp {
+  public:
+    ZuluTimeImp(int hr, int min, int zone): TimeImp(hr, min) {
+        if (zone == 5)
+          strcpy(zone_, " Eastern Standard Time");
+        else if (zone == 6)
+          strcpy(zone_, " Central Standard Time");
+    }
+
+    /* virtual */
+    void tell() {
+        cout << "time is " << setw(2) << setfill(48) << hr_ << min_ << zone_ <<
+          endl;
+    }
+  protected:
+    char zone_[30];
+};
+
+class Time {
+  public:
+    Time(){}
+    Time(int hr, int min) {
+        imp_ = new TimeImp(hr, min);
+    }
+    virtual void tell() {
+        imp_->tell();
+    }
+  protected:
+    TimeImp *imp_;
+};
+
+class CivilianTime: public Time {
+  public:
+    CivilianTime(int hr, int min, int pm) {
+        imp_ = new CivilianTimeImp(hr, min, pm);
+    }
+};
+
+class ZuluTime: public Time {
+  public:
+    ZuluTime(int hr, int min, int zone) {
+        imp_ = new ZuluTimeImp(hr, min, zone);
+    }
+};
+
+int main() {
+  Time *times[3];
+  times[0] = new Time(14, 30);
+  times[1] = new CivilianTime(2, 30, 1);
+  times[2] = new ZuluTime(14, 30, 6);
+  for (int i = 0; i < 3; i++)
+    times[i]->tell();
+}

design patterns/structural pattern/bridge pattern/bridge_pattern.cc

@@ -0,0 +1,5 @@
+Bridge is a structural design pattern that lets you split a giant class or a set of closely related classes into two separate hierarchies, abstraction and implementation, which can be developed independently of each other.
+
+
+The motivation is to decouple the Time interface from the Time implementation, while still allowing the abstraction and the realization to each be modelled with their own inheritance hierarchy. The implementation classes below are straight-forward. The interface classes are a little more subtle. Routinely, a Bridge pattern interface hierarchy "has a" implementation class. Here the interface base class "has a" a pointer to the implementation base class, and each class in the interface hierarchy is responsible for populating the base class pointer with the correct concrete implementation class. Then all requests from the client are simply delegated by the interface class to the encapsulated implementation class.
+