home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / odb.zip / INCLUDE / ODB.H
C/C++ Source or Header  |  1996-12-08  |  15KB  |  496 lines
  1. //----------------------------------------------------
  2. //
  3. //          Declaration file to project store
  4. //
  5. //----------------------------------------------------
  6. #ifdef _SOODB_
  7. #else
  8. #define _SOODB_
  9.  
  10. //Type identifiers
  11. #define _INT_ 0
  12. #define _REAL_ 1
  13. #define _CHAR_ 3
  14. #define _OBJECT_ 4
  15. #define _COLLECTION_ 5
  16. #define _OBJECT_COLLECTION_ 5
  17. #define _INT_COLLECTION_ 6
  18. #define _REAL_COLLECTION_ 7
  19. #define _CHAR_COLLECTION_ 8
  20. #define _SET_COLLECTION_ 9
  21.  
  22. //Type names
  23. #define _INT_NM_ "Integer"
  24. #define _REAL_NM_ "Real"
  25. #define _CHAR_NM_ "Charstring"
  26. #define _OBJECT_NM_ "Object Reference"
  27. #define _COLLECTION_NM_ "Object Collection"
  28. #define _INT_COLLECTION_NM_ "Integer Collection"
  29. #define _REAL_COLLECTION_NM_ "Real Collection"
  30. #define _CHAR_COLLECTION_NM_ "Charstring Collection"
  31. #define _SET_COLLECTION_NM_ "Collection Collection"
  32.  
  33. #define _ERRORTYPE_ -1
  34. #define _ALL_ -3    //_ALL_ for scanning whole table
  35. #define _BUCKET_ -4 // for scanning bucket only
  36. #define _NoName_ "NoName"
  37. #define NO_PROPS 0
  38. #define WITH_PROPS 1
  39. //Tags for saving and loading database to file
  40. #define _Typestart_ "Type"
  41. #define _Typeend_ "/Type"
  42. #define _Propstart_ "Props"
  43. #define _Propend_ "/Props"
  44. #define _Indexstart_ "Index"
  45. #define _Indexend_ "/Index"
  46. #define _Usertypes_ "Usertypes"
  47. #define _Subtypestart_ "Subtype_of"
  48. #define _Databaseend_ "/Database"
  49. #define _Populationstart_ "Objects"
  50. #define _Populationend_ "/Objects"
  51. #define _Objstart_ "Instance"
  52. #define _Objend_ "/Instance"
  53. #define _Setstart_ "{"
  54. #define _Setend_ "}"
  55. #define _NULL_ "NULL"
  56. #define _OID_ "OID"
  57.  
  58.  
  59. #include <iostream.h>
  60. #include <fstream.h>
  61.  
  62.  
  63.  
  64. //forward declarations
  65. class type;
  66. class object;
  67. class database;
  68. class table;
  69. class query_stream;
  70. class select_stream;
  71. class semi_join_stream;
  72. class collection;
  73. class property_value;
  74. class linked_list;
  75. class stringtable;
  76. struct indextp;
  77. struct typestp;
  78.  
  79. //Type defs
  80. typedef signed long int ODB_INT;
  81. typedef double ODB_REAL;
  82. typedef signed long int ODB_OID;
  83. typedef char * ODB_CHAR;
  84. typedef object * ODB_REF;
  85. typedef collection *ODB_SET;
  86. typedef query_stream *ODB_QSTREAM;
  87. typedef select_stream *ODB_SSTREAM;
  88. typedef semi_join_stream *ODB_SJSTREAM;
  89. typedef database ODB_DB;
  90. typedef database * ODB_DB_HANDLE;
  91. typedef type *ODB_TYPE;
  92. typedef int ODB_TYPE_TAG;
  93. typedef char * ODB_NAME;
  94. typedef property_value * ODB_PROP;
  95.  
  96. //class definitios
  97.  
  98. class outputbuffer
  99. {private:
  100.     char buf[1024];
  101.     char *currpos;
  102.     int len,maxsize;
  103. public:
  104.     outputbuffer(void);
  105.     char *write_request(int maxlen);
  106.     char *get_buffer(void);
  107.     void reset_buffer(void);
  108. };
  109.  
  110. class collection
  111. {private:
  112.     int type;
  113.     ODB_REF obj;
  114.     ODB_CHAR charstring;
  115.     ODB_SET setval;
  116.     ODB_INT intval;
  117.     ODB_REAL realval;
  118.     ODB_SET next;
  119.     int empty;
  120.     void displayelements(outputbuffer &buf);
  121. public:
  122.     collection (int tp);
  123.     int is_empty(void);
  124.     int insert(ODB_REF obj);
  125.     int insert(ODB_CHAR charstring);
  126.     int insert(ODB_SET setval);
  127.     int insert(ODB_INT intval);
  128.     int insert(ODB_REAL realval);
  129.     int delete_element(ODB_REF obj);
  130.     int delete_element(ODB_INT i);
  131.     int delete_element(ODB_REAL r);
  132.     int delete_element(ODB_CHAR c);
  133.     void delete_set(void);
  134.     void null_reference_to(ODB_REF o);
  135.     int gettype(void);
  136.     ODB_INT getintval(void);
  137.     ODB_CHAR getcharstringval(void);
  138.     ODB_REAL getrealval(void);
  139.     ODB_REF getobj(void);
  140.     ODB_SET getsetval(void);
  141.     ODB_SET getnext(void);
  142.     int set_next_to(ODB_SET sv);
  143.     void display(outputbuffer &buf);
  144.     int member(ODB_INT i);
  145.     int member(ODB_CHAR c);
  146.     int member(ODB_REAL r);
  147.     int member(ODB_REF o); //not impl
  148.     int member(ODB_SET s);
  149.     int equal(ODB_SET s);
  150.     int saveset(ofstream *databasefile);
  151.     int populatefromfile(ifstream *databasefile,int datatype,struct tblentry *maptable,database *db);
  152. };
  153.  
  154.  
  155. class property_value
  156. {private:
  157.     int valuetype;
  158.     ODB_INT intval;
  159.     ODB_REAL realval;
  160.     ODB_CHAR charstring;
  161.     ODB_REF elem;
  162.     ODB_SET setval;
  163.     ODB_NAME name;
  164.     ODB_PROP nextprop;
  165.     int setsize(int val);
  166. public:
  167.     int gettype(void);
  168.     ODB_INT getintval(void);
  169.     ODB_CHAR getcharstringval(void);
  170.     ODB_REAL getrealval(void);
  171.     ODB_REF getelem(void);
  172.     ODB_SET getsetval(void);
  173.     ODB_NAME getname(void);
  174.     ODB_PROP nextproperty(void);
  175.     property_value(int t, ODB_NAME nm, database *db);
  176.     ~property_value(void);
  177.     int setintval(ODB_INT val);
  178.     int setcharstringval(ODB_CHAR val, database *db);
  179.     int setrealval(ODB_REAL val);
  180.     int setelem(ODB_REF val);
  181.     int setsetval(ODB_SET sv);
  182.     int setnextto(ODB_PROP next);
  183.     int changenextto(ODB_PROP next);
  184.     ODB_PROP copy_prop(database *db);
  185.     void display(outputbuffer &buf);
  186.     int saveprop(ofstream *databasefile);
  187. };
  188.  
  189. class object
  190. {protected:
  191.     ODB_OID OID;
  192.     ODB_PROP props;
  193.     type *typeof;
  194.  
  195.  public:
  196.     ODB_OID oid(void);
  197.     void display(outputbuffer &buf);
  198.     void displayoid(outputbuffer &buf);
  199.     object(void);
  200.     object(type *tp, database *db);
  201.     int getoid(void);
  202.     ODB_REF add_newproperty(int tp, ODB_NAME nm);
  203.     ODB_PROP putprop(ODB_PROP newprop);
  204.     ODB_PROP setproperty_value(ODB_NAME name,ODB_INT intval);
  205.     ODB_PROP setproperty_value(ODB_NAME name,ODB_REAL val);
  206.     ODB_PROP setproperty_value(ODB_NAME name,ODB_CHAR val);
  207.     ODB_PROP setproperty_value(ODB_NAME name,ODB_REF refobj);
  208.     ODB_PROP setproperty_value(ODB_NAME name,ODB_SET sv);
  209.     ODB_PROP getpropertynamed(ODB_NAME name);
  210.     void deleteobject(void);
  211.     ~object(void);
  212.     int saveobject(ofstream *databasefile,int how);
  213.     int delete_instanceproperty(ODB_NAME propnm);
  214.  };
  215.  
  216.  
  217.  
  218.  
  219. class type : public object
  220. { private:
  221.     int card;
  222.     char name[20];
  223.     table *extent;
  224.     indextp *index;
  225.     typestp *supertypes;
  226.     typestp *subtypes;
  227.     indextp *makenewindex(ODB_NAME nm);
  228.     indextp *populateindex(ODB_NAME nm,indextp *thenewindex);
  229.     int insertintoallindex(ODB_REF obj);
  230.     database *belongsto;
  231.     ODB_PROP inherited_props;
  232.     typestp *ext_start, *ext_end, *curr_ext;
  233.     typestp *curr_stp;  //for scanning all subtypes, one by one
  234.     ODB_PROP propptr; //for scanning all properties
  235.  
  236.  public:
  237.     type(void);
  238.     type(ODB_NAME nm, database *db);
  239.     type(ODB_NAME nm, type *super, database *db);
  240.     void delete_type(void);
  241.     void remove_subtype(type *t);
  242.     type *getsupertype(void);
  243.     int set_belongsto(database *db);
  244.     int addsubtype(type *tp, typestp *extp);
  245.     int readdsubtype(typestp *extp);
  246.     int extend_extent(typestp *extptr);
  247.     void rebuild_extentlist(void);
  248.     type *add_property(int tp, ODB_NAME nm);
  249.     type *add_inheritedproperty(int tp, ODB_NAME nm);
  250.     int drop_index(ODB_NAME propnm);
  251.     void display(outputbuffer &buf);
  252.     void displayname(outputbuffer &buf);
  253.     ODB_PROP getprops(void);
  254.     ODB_PROP get_noninherited_propertynamed(ODB_NAME nm);
  255.     void delete_inherited_props(ODB_NAME pnm);
  256.     ODB_REF create_instance(void);
  257.     void displayextent(outputbuffer &buf);
  258.     int build_index(ODB_NAME prop);
  259.     table *getindexnamed(ODB_NAME nm);
  260.     table *getextent(void);
  261.     query_stream *open(void);
  262.     query_stream *open(ODB_NAME nm,ODB_NAME op,ODB_INT intval);
  263.     query_stream *open(ODB_NAME nm,ODB_NAME op,ODB_REAL realval);
  264.     query_stream *open(ODB_NAME nm,ODB_CHAR charstringval);
  265.     query_stream *open(ODB_NAME nm,ODB_REF objval);
  266.     query_stream *open(ODB_NAME nm,ODB_SET sv);
  267.     int remove_all_references_to(ODB_REF o);
  268.     int deleteobject(ODB_REF obj);
  269.     int savetypes(ofstream *databasefile);
  270.     int saveobjects(ofstream *databasefile,int how);
  271.     type *gettypenamed(ODB_NAME nm);
  272.     database *getdb(void);
  273.     ODB_NAME getname(void);
  274.     //next a bunch of fns to scan subtypes, properties, deep extent ...
  275.     ODB_NAME getallsubtypes(void);
  276.     ODB_NAME getnextsubtype(void);
  277.     ODB_NAME getsubtypes(void);
  278.     ODB_NAME getsubtype(void);
  279.     ODB_NAME getfirstprop(void);
  280.     ODB_NAME getnextprop(void);
  281.     int validate(ODB_NAME inp,void *obj);
  282.  };
  283.  
  284. class query_stream
  285. {protected:
  286.     int bucket; //offset in table
  287.     int scantype; //index use or scan
  288.     linked_list *lst; //actual object holder in table
  289.     type *ctp; //current type being accessed
  290.     table *tbl;
  291.     typestp *exs, *exe, *curre;
  292.     ODB_REF currobj;
  293.     int datatype;
  294.     ODB_NAME prop;
  295.     ODB_INT intval;
  296.     ODB_REAL realval;
  297.     ODB_CHAR charstringval;
  298.     ODB_REF objval;
  299.     ODB_SET setval;
  300.     ODB_NAME op;
  301.     int eval_op(ODB_NAME op,ODB_INT objval,ODB_INT cmpval);
  302.     int eval_op(ODB_NAME op,ODB_REAL objval,ODB_REAL cmpval);
  303.     int eval(ODB_SET sv,ODB_INT cmpval);
  304.     int eval(ODB_SET sv,ODB_REAL cmpval);
  305.     int eval(ODB_SET sv,ODB_CHAR cmpval);
  306.     int eval(ODB_SET sv,ODB_REF cmpval);
  307.     int eval(ODB_SET sv,ODB_SET cmpval);
  308.     int evalsetexpr(ODB_SET sv);
  309.     ODB_REF getint(ODB_INT inval);
  310.     ODB_REF getreal(ODB_REAL realval);
  311.     ODB_REF getcharstring(ODB_CHAR charstringval);
  312.     ODB_REF getobj(ODB_REF objval);
  313.     ODB_REF getset();
  314.     void move_to_next_extent(ODB_INT iv,type *tptr);
  315.     void move_to_next_extent(ODB_REAL rv,type *tptr);
  316.     void move_to_next_extent(ODB_CHAR cv,type *tptr);
  317.     void move_to_next_extent(ODB_REF ov,type *tptr);
  318.     void move_to_next_extent(ODB_SET sv,type *tptr);
  319.     void move_to_next_extent(type *tptr);
  320. public:
  321.     //initializers and modifiers
  322.     query_stream(void);
  323.     int set_operator(ODB_NAME op);
  324.     int set_currbuck(int i);
  325.     int set_currlst(linked_list *l);
  326.     int set_scantype(int s);
  327.     int set_currobj(ODB_REF o);
  328.     int set_currtype(type *t);
  329.     int set_table(table *t);
  330.     int set_extentstart(typestp *es);
  331.     int set_extentend(typestp *ee);
  332.     int set_datatype(int i);
  333.     int set_prop(ODB_NAME p);
  334.     int set_intval(ODB_INT i);
  335.     int set_realval(ODB_REAL f);
  336.     int set_charstringval(ODB_CHAR cv);
  337.     int set_objval(ODB_REF o);
  338.     int set_setval(ODB_SET s);
  339.  
  340.     //retrievers
  341.     ODB_NAME get_operator(void);
  342.     int get_currbuck(void);
  343.     linked_list *get_currlst(void);
  344.     int get_scantype(void);
  345.     ODB_REF get_currobj(void);
  346.     type *get_currtype(void);
  347.     table *get_table(void);
  348.     ODB_NAME get_prop(void);
  349.     ODB_INT get_intval(void);
  350.     ODB_REAL get_realval(void);
  351.     ODB_CHAR get_charstringval(void);
  352.     ODB_REF get_objval(void);
  353.     ODB_SET get_setval(void);
  354.     int get_datatype(void);
  355.  
  356.     //query primitives
  357.     virtual ODB_REF get(void);
  358.         virtual void close(void);
  359.     virtual int reset(void);
  360.     //open other streams on this
  361.     select_stream *open_select_stream(ODB_NAME prop,ODB_NAME oop,ODB_INT intval);
  362.     select_stream *open_select_stream(ODB_NAME prop,ODB_NAME oop, ODB_REAL realval);
  363.     select_stream *open_select_stream(ODB_NAME prop,ODB_CHAR charstringval);
  364.     select_stream *open_select_stream(ODB_NAME prop,ODB_REF objval);
  365.     select_stream *open_select_stream(ODB_NAME pr,ODB_SET sv);
  366.     semi_join_stream *open_sj_stream(ODB_NAME prop1, query_stream *st2, ODB_NAME prop2);
  367.  
  368.     //misc
  369.     void display(outputbuffer &buf);
  370. };
  371.  
  372. class select_stream : public query_stream
  373. {private:
  374.     query_stream *qs;
  375.     ODB_REF getint(void);
  376.     ODB_REF getreal(void);
  377.     ODB_REF getcharstring(void);
  378.     ODB_REF getobj(void);
  379.     ODB_REF getset(void);
  380. public:
  381.     select_stream(void);
  382.     select_stream(query_stream *q,ODB_NAME nm,ODB_NAME oop,ODB_INT i);
  383.     select_stream(query_stream *q,ODB_NAME nm,ODB_NAME oop,ODB_REAL r);
  384.     select_stream(query_stream *q,ODB_NAME nm,ODB_CHAR chrstr);
  385.     select_stream(query_stream *q,ODB_NAME nm,ODB_REF ob);
  386.     select_stream(query_stream *q,ODB_NAME nm,ODB_SET sv);
  387.     ODB_REF get();
  388.     void close(void);
  389.     int reset(void);
  390. };
  391.  
  392. class semi_join_stream : public query_stream
  393. {private:
  394.     query_stream *lops; //left operand stream;
  395.     query_stream *rops; //right operand stream
  396.     ODB_NAME rprop;
  397.     ODB_REF getint(void);
  398.     ODB_REF getreal(void);
  399.     ODB_REF getcharstring(void);
  400.     ODB_REF getobj(void);
  401.     object*getobjspecial(void);
  402.     int set_rprop(ODB_NAME p);
  403.     ODB_NAME get_rprop(void);
  404. public:
  405.     semi_join_stream(void);
  406.     semi_join_stream(query_stream *lop,ODB_NAME lnm,query_stream *rop,ODB_NAME rnm);
  407.     ODB_REF get();
  408.     void close(void);
  409.     int reset(void);};
  410.  
  411. class database
  412. {private:
  413.     ODB_NAME name;
  414.     ODB_OID global_oid;
  415.     int default_tablesize;
  416.     type usertypes;
  417.     int makefilename(ODB_NAME nm, ODB_NAME filename);
  418.     stringtable *strtbl;
  419.     char inpbuf[1024];
  420. public:
  421.     ODB_OID generate_oid(void);
  422.     int get_tablesize(void);
  423.     ODB_NAME get_dbname(void);
  424.     type *get_usertypes(void);
  425.     type *create_type(ODB_NAME nm);
  426.     type *create_type(ODB_NAME nm, ODB_NAME supt);
  427.     void display(outputbuffer &buf);
  428.     int save_database(ODB_NAME nm);
  429.     int load_database(ODB_NAME nm);
  430.     type *gettypenamed(ODB_NAME nm);
  431.     database(ODB_NAME nm); //constructor
  432.     database(void); //default constructor
  433.     int initialize(void);
  434.     ODB_NAME getstring(ODB_NAME st);
  435.     query_stream *open_stream(ODB_NAME tpname);
  436.     query_stream *open_stream(ODB_NAME tpname, ODB_NAME propnm,ODB_NAME op,ODB_INT i);
  437.     query_stream *open_stream(ODB_NAME tpname, ODB_NAME propnm,ODB_NAME op,ODB_REAL f);
  438.     query_stream *open_stream(ODB_NAME tpname, ODB_NAME propnm,ODB_CHAR ch);
  439.     query_stream *open_stream(ODB_NAME tpname, ODB_NAME propnm,ODB_REF o);
  440.     select_stream *select(query_stream *qst,ODB_NAME propnm,ODB_NAME oop,ODB_INT i);
  441.     select_stream *select(query_stream *qst,ODB_NAME propnm,ODB_NAME oop,ODB_REAL f);
  442.     select_stream *select(query_stream *qst,ODB_NAME propnm,ODB_CHAR ch);
  443.     select_stream *select(query_stream *qst,ODB_NAME propnm,ODB_REF o);
  444.     semi_join_stream *semi_join(query_stream *ls,ODB_NAME p1,query_stream *rs,ODB_NAME p2);
  445.     ODB_REF get(query_stream *qst);
  446.     int close_stream(query_stream *qst);
  447.     int reset_stream(query_stream *qst);
  448.     //The following pais of functions is for get metainfo
  449.     //in a ony by one fasion.
  450.     ODB_NAME getallsubtypes(void); //all subtypes
  451.     ODB_NAME getnextsubtype(void); //continues the above
  452.     ODB_NAME getsubtypes(ODB_NAME tpnm);//direct subtypes
  453.     ODB_NAME getsubtype(ODB_NAME tpnm);
  454.     ODB_NAME getfirstprop(ODB_NAME tpnm);
  455.     ODB_NAME getnextprop(ODB_NAME tpnm);
  456.     ODB_NAME getsupertype(ODB_NAME tpnm);
  457.     int getpropertytype(ODB_NAME tpnm, ODB_NAME propnm);
  458.     int add_property(ODB_NAME tpname, ODB_NAME prname,int tp);
  459.     ODB_REF getobjectwithoid(ODB_NAME tpnm,ODB_OID oid);
  460.     ODB_REF create_instance(ODB_NAME tpnm);
  461.     ODB_NAME set_name(ODB_NAME nm);
  462.     int set_tablesize(int s);
  463.     int create_index(ODB_NAME tpnm, ODB_NAME propnm);
  464.     int drop_index(ODB_NAME tpnm, ODB_NAME propnm);
  465.     int delete_property(ODB_NAME tpnm,ODB_NAME propnm);
  466.     int delete_type(ODB_NAME tpnm);
  467.     int delete_object(ODB_REF o);
  468.  
  469.     //Updating property values
  470.     int setproperty_value(ODB_REF o,ODB_NAME name,ODB_INT intval);
  471.     int setproperty_value(ODB_REF o,ODB_NAME name,ODB_REAL realval);
  472.     int setproperty_value(ODB_REF o,ODB_NAME name,ODB_CHAR charval);
  473.     int setproperty_value(ODB_REF o,ODB_NAME name,ODB_REF refval);
  474.     int setproperty_value(ODB_REF o,ODB_NAME name,ODB_SET setval);
  475.  
  476.     //retreiving property values
  477.     int getproperty_value(ODB_REF o,ODB_NAME propnm, ODB_INT *iv);
  478.     int getproperty_value(ODB_REF o,ODB_NAME propnm, ODB_REAL *rv);
  479.     int getproperty_value(ODB_REF o,ODB_NAME propnm, ODB_REF *ov);
  480.     int getproperty_value(ODB_REF o,ODB_NAME propnm, ODB_CHAR *nm);
  481.     int getproperty_value(ODB_REF o,ODB_NAME propnm, ODB_SET *nm);
  482.  
  483.     //collection stuff
  484.     ODB_SET create_collection(int tp);
  485.     int collection_insert(ODB_SET coll,ODB_INT iv);
  486.     int collection_insert(ODB_SET coll,ODB_REAL rv);
  487.     int collection_insert(ODB_SET coll,ODB_SET sv);
  488.     int collection_insert(ODB_SET coll,ODB_CHAR cv);
  489.     int collection_insert(ODB_SET coll,ODB_REF ref);
  490.     int delelete_collection(ODB_SET coll);
  491. };
  492.  
  493.  
  494.  
  495. #endif
  496.