Tree-M/MT/MTobject.h

/*********************************************************************
*                                                                    *
* Copyright (c) 1997,1998, 1999                                      *
* Multimedia DB Group and DEIS - CSITE-CNR,                          *
* University of Bologna, Bologna, ITALY.                             *
*                                                                    *
* All Rights Reserved.                                               *
*                                                                    *
* Permission to use, copy, and distribute this software and its      *
* documentation for NON-COMMERCIAL purposes and without fee is       *
* hereby granted provided  that this copyright notice appears in     *
* all copies.                                                        *
*                                                                    *
* THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT THE        *
* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING  *
* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY,      *
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHOR  *
* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A      *
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS    *
* DERIVATIVES.                                                       *
*                                                                    *
*********************************************************************/

#ifndef MTOBJECT_H
#define MTOBJECT_H

extern int compdists;
extern int dimension;

#ifndef MIN
#define MIN(x, y) ((x<y)? (x): (y))
#define MAX(x, y) ((x>y)? (x): (y))
#endif

#include <stdio.h>
//#include <string.h>
#include "GiSTdefs.h"

/*
typedef struct term_weight {
        int id_term;
        float weight;
        struct term_weight *next;
} Term_Weight;

class Object : public GiSTobject        // the DB object class
{
public:
        int tot_term;
        Term_Weight     *lst_tw;

//      long wasted_space[100]; // only for debug purposes

        Object() {      // default constructor (needed)
                tot_term=0;
                lst_tw=NULL;
        }  

        Object(const Object& obj) {     // copy constructor (needed)
                Term_Weight **tail=&lst_tw;

                tot_term=obj.tot_term;
                for(Term_Weight *p=obj.lst_tw; p; p=p->next) {
                        Term_Weight *m=new Term_Weight;

                        m->id_term=p->id_term;
                        m->weight=p->weight;
                        *tail=m;
                        tail=&(m->next);
                }
                *tail=NULL;
        }

        Object(char *key) {     // member constructor (needed)
                Term_Weight **tail=&lst_tw;

                memcpy(&tot_term, key, sizeof(int));
                for(int i=0; i<tot_term; i++) {
                        Term_Weight *m=new Term_Weight;

                        memcpy(&(m->id_term), key+sizeof(int)+i*(sizeof(int)+sizeof(float)), sizeof(int));
                        memcpy(&(m->weight), key+sizeof(int)+i*(sizeof(int)+sizeof(float))+sizeof(int), sizeof(float));
                        *tail=m;
                        tail=&(m->next);
                }
                *tail=NULL;
        }

        Object(Term_Weight *p_x) {      // member constructor (needed)
                Term_Weight **tail=&lst_tw;

                tot_term=0;
                for(Term_Weight *p=p_x; p; p=p->next) {
                        Term_Weight *m=new Term_Weight;

                        m->id_term=p->id_term;
                        m->weight=p->weight;
                        tot_term++;
                        *tail=m;
                        tail=&(m->next);
                }
                *tail=NULL;
        }

        ~Object() {     // destructor
                Term_Weight *p;

                for (Term_Weight *m=lst_tw; m; m=p) {
                        p=m->next;
                        delete m;
                }
        }

        Object& operator=(const Object& obj) {  // assignment operator (needed)
                Term_Weight *m, *p, **tail=&lst_tw;

                for (m=lst_tw; m; m=p) {
                        p=m->next;
                        delete m;
                }
                tot_term=obj.tot_term;
                for(p=obj.lst_tw; p; p=p->next) {
                        m=new Term_Weight;
                        m->id_term=p->id_term;
                        m->weight=p->weight;
                        *tail=m;
                        tail=&(m->next);
                }
                *tail=NULL;
                return *this;
        }

        double area(double r) { // only needed for statistic purposes (dependent on the metric, not applicable for non-vector metric spaces)
                return 0;
        };

        int operator==(const Object& obj);      // equality operator (needed)

        int operator!=(const Object& obj) { return !(*this==obj); };    // inequality operator (needed)

        double distance(const Object& other) const;     // distance method (needed)
        int CompressedLength() const;   // return the compressed size of this object
        void Compress(char *key) {      // object compression
                int i=0;

                memcpy(key, &tot_term, sizeof(int));
                for(Term_Weight *p=lst_tw; p; p=p->next) {
                        memcpy(key+sizeof(int)+i*(sizeof(int)+sizeof(float)), &(p->id_term), sizeof(int));
                        memcpy(key+sizeof(int)+i*(sizeof(int)+sizeof(float))+sizeof(int), &(p->weight), sizeof(float));
                        i++;
                }
        }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const;
#endif
};

double maxDist();       // return the maximum value for the distance between two objects
int sizeofObject();     // return the compressed size of each object (0 if objects have different sizes)

        Object *Read(); // read an object from standard input
        Object *Read(FILE *fp); // read an object from a file
*/

#include "../object.h"

#endif
Revision:	1.1
Committed:	Sun May 6 00:45:52 2001 UTC (23 years ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	Content
1	/*********************************************************************
2	* *
3	* Copyright (c) 1997,1998, 1999 *
4	* Multimedia DB Group and DEIS - CSITE-CNR, *
5	* University of Bologna, Bologna, ITALY. *
6	* *
7	* All Rights Reserved. *
8	* *
9	* Permission to use, copy, and distribute this software and its *
10	* documentation for NON-COMMERCIAL purposes and without fee is *
11	* hereby granted provided that this copyright notice appears in *
12	* all copies. *
13	* *
14	* THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT THE *
15	* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING *
16	* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, *
17	* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHOR *
18	* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A *
19	* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS *
20	* DERIVATIVES. *
21	* *
22	*********************************************************************/
23
24	#ifndef MTOBJECT_H
25	#define MTOBJECT_H
26
27	extern int compdists;
28	extern int dimension;
29
30	#ifndef MIN
31	#define MIN(x, y) ((x<y)? (x): (y))
32	#define MAX(x, y) ((x>y)? (x): (y))
33	#endif
34
35	#include <stdio.h>
36	//#include <string.h>
37	#include "GiSTdefs.h"
38
39	/*
40	typedef struct term_weight {
41	int id_term;
42	float weight;
43	struct term_weight *next;
44	} Term_Weight;
45
46	class Object : public GiSTobject // the DB object class
47	{
48	public:
49	int tot_term;
50	Term_Weight *lst_tw;
51
52	// long wasted_space[100]; // only for debug purposes
53
54	Object() { // default constructor (needed)
55	tot_term=0;
56	lst_tw=NULL;
57	}
58
59	Object(const Object& obj) { // copy constructor (needed)
60	Term_Weight **tail=&lst_tw;
61
62	tot_term=obj.tot_term;
63	for(Term_Weight *p=obj.lst_tw; p; p=p->next) {
64	Term_Weight *m=new Term_Weight;
65
66	m->id_term=p->id_term;
67	m->weight=p->weight;
68	*tail=m;
69	tail=&(m->next);
70	}
71	*tail=NULL;
72	}
73
74	Object(char *key) { // member constructor (needed)
75	Term_Weight **tail=&lst_tw;
76
77	memcpy(&tot_term, key, sizeof(int));
78	for(int i=0; i<tot_term; i++) {
79	Term_Weight *m=new Term_Weight;
80
81	memcpy(&(m->id_term), key+sizeof(int)+i*(sizeof(int)+sizeof(float)), sizeof(int));
82	memcpy(&(m->weight), key+sizeof(int)+i*(sizeof(int)+sizeof(float))+sizeof(int), sizeof(float));
83	*tail=m;
84	tail=&(m->next);
85	}
86	*tail=NULL;
87	}
88
89	Object(Term_Weight *p_x) { // member constructor (needed)
90	Term_Weight **tail=&lst_tw;
91
92	tot_term=0;
93	for(Term_Weight *p=p_x; p; p=p->next) {
94	Term_Weight *m=new Term_Weight;
95
96	m->id_term=p->id_term;
97	m->weight=p->weight;
98	tot_term++;
99	*tail=m;
100	tail=&(m->next);
101	}
102	*tail=NULL;
103	}
104
105	~Object() { // destructor
106	Term_Weight *p;
107
108	for (Term_Weight *m=lst_tw; m; m=p) {
109	p=m->next;
110	delete m;
111	}
112	}
113
114	Object& operator=(const Object& obj) { // assignment operator (needed)
115	Term_Weight m, p, **tail=&lst_tw;
116
117	for (m=lst_tw; m; m=p) {
118	p=m->next;
119	delete m;
120	}
121	tot_term=obj.tot_term;
122	for(p=obj.lst_tw; p; p=p->next) {
123	m=new Term_Weight;
124	m->id_term=p->id_term;
125	m->weight=p->weight;
126	*tail=m;
127	tail=&(m->next);
128	}
129	*tail=NULL;
130	return *this;
131	}
132
133	double area(double r) { // only needed for statistic purposes (dependent on the metric, not applicable for non-vector metric spaces)
134	return 0;
135	};
136
137	int operator==(const Object& obj); // equality operator (needed)
138
139	int operator!=(const Object& obj) { return !(*this==obj); }; // inequality operator (needed)
140
141	double distance(const Object& other) const; // distance method (needed)
142	int CompressedLength() const; // return the compressed size of this object
143	void Compress(char *key) { // object compression
144	int i=0;
145
146	memcpy(key, &tot_term, sizeof(int));
147	for(Term_Weight *p=lst_tw; p; p=p->next) {
148	memcpy(key+sizeof(int)+i*(sizeof(int)+sizeof(float)), &(p->id_term), sizeof(int));
149	memcpy(key+sizeof(int)+i*(sizeof(int)+sizeof(float))+sizeof(int), &(p->weight), sizeof(float));
150	i++;
151	}
152	}
153
154	#ifdef PRINTING_OBJECTS
155	void Print(ostream& os) const;
156	#endif
157	};
158
159	double maxDist(); // return the maximum value for the distance between two objects
160	int sizeofObject(); // return the compressed size of each object (0 if objects have different sizes)
161
162	Object *Read(); // read an object from standard input
163	Object Read(FILE fp); // read an object from a file
164	*/
165
166	#include "../object.h"
167
168	#endif