====== io ======

Io ist quasi die Factory für Ein-Ausgabefunktionen.

<code cpp>
Point contains x, y is double;
p is Point( 1., 2. );

file is io( "json://test.test" );

file << p;  // schreibt "{ 1., 2. }" in die Datei.

q is Point;

file.rewind();

file >> q;  // Lädt den Punkt wieder ein.
</code>

Von io kann man ableiten:

<code>
json is io( "json" )  // Konstruktor gilt für alle
     is file           // muss noch konstruiert werden oder default
     contains
{
  operator persistent is int;  //  erkärt, dass persistent-Objekte, ein int enthalten muss. Ein Persistent Objekt enthält zwei Zeiger: Zum io Objekt und zu einem beliebigen Objekt (void *) oder - sofern es passt, wie int
  
  
  Filename is string;
  
  construct( Filename ) := file( Filename );
  
  operator <<( rhs is reflected ) as this
  {
    file << "{ ";    
    
    rhs.isPrimitive() then
    {   
      file << "{ \n";

      rhs@{}.
      {
        index? then print ",\n";
        
        file << "  " << item.value( rhs );  // item ist vom Typ Point@ wenn Point als rhs übergeben wurde. Point@.value( xx) erwartet ein Point. rhs ist Point => passt.
      }

      file << "\n}\n";
    }      
          
    // return this; // nicht erforderlich, steht ja schon da (as this)  
  } 
  
  operator <<( rhs is persistent reflected ) as this
  {
    .. wie oben, aber rhs hat ein UserData-Zeiger (persistent) für existiert.
    
    existing is unsigned int : persistent( rhs ); // persistent() geht innerhalb von io und prüft, ob das Userdata überhaupt passt
    
    
    
  } 
  
}
</code>


===== reflect =====

Mit [[notes:reflect:]] lassen sich - je nach Datenquelle - Typen erstellen.

<code>
db is io("mysql://localhost/")


string [] dbs = db.ls();

print[] (dbs, ", ");  // ( db1, db2, dbname, )

db.cd( "dbname" );

string[] tables = db.ls();

Point contains x, y is double persist mysql;

db.create( type Point );  // Legt eine Datenbank "Point" mit drei Spalten an: "_id" (AUTOINCREMENT), "x", "y"

print desc Point;   // Point is struct ( 16 Bytes, 2 Member )

p is Point : ( 1, 2 );

index is int : db{ "Point" } << p;  // Legt einen neuen Datensatz an

pp is persistent Point;    // Ableitung von Point und ein UserData Zeiger, der dem jeweiligen io-Objekt (inkl. Position) zur Verfügung steht

pp << db{ index };

pp << db{ "x == 1" };
</code>


Man kann auch ganze Datenbanken in den Speicher holen:

<code>
db.cd( "/dbname" );
Points is something << db;

print desc Points; // int -> persistent Point  (hash)

p is ref Point : Points{ 1 };

p.y = 4711;

p >> db;  // p ist referenz, die Referenz wird zur Datenbank aktualisiert (UPDATE)
</code>


Reflektierte Typen können benutzt werden, um COde zu generieren.

<code>
db is io("mysql://localhost/dbname/Points")

type table : db.reflect();

emit table;
</code>

Ergibt
<code>
Point contains
{
  x is double;
  y is double;

  default is persistant:  // default ist ein Array und wird für mysql beschrieben.
  {
    mysql( "Point" ):
    {
      x -> "x",
      y -> "y"
    };
  };
};
</code>