bool Plan_File::Open (char *filename)
{
bool stat;
if (filename != NULL) {
Filename (filename);
}
filename = Filename ();
if (*filename != '\0' && File_Access () != CREATE) {
stat = Read_Plan_Def ();
} else {
stat = false;
}
//---- open the file ----
if (Db_File::Open ()) {
if (!stat || File_Access () == CREATE) {
return (Write_Plan_Def ());
}
return (true);
}
return (false);
}
bool Db_File::Db_Open (string filename)
{
ios_base::openmode code;
int sqlite_code = 0;
bool sqlite_flag = (File_Format () == SQLITE3);
file.clear ();
if (sqlite_flag && Nest_Flag ()) {
exe->File_Error ("SQLITE3 does not support Nested Files", filename);
return (Status (NOT_OPEN));
}
switch (File_Access ()) {
default:
return (Status (DB_ERROR));
break;
case READ:
if (sqlite_flag) {
sqlite_code = SQLITE_OPEN_READONLY;
} else {
code = ios_base::in;
}
break;
case MODIFY:
if (sqlite_flag) {
sqlite_code = SQLITE_OPEN_READWRITE;
} else {
code = ios_base::in | ios_base::out;
}
break;
case APPEND:
if (sqlite_flag) {
sqlite_code = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
} else {
code = ios_base::in | ios_base::out | ios_base::app;
}
break;
case CREATE:
if (sqlite_flag) {
remove (filename.c_str ());
sqlite_code = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
} else {
code = ios_base::in | ios_base::out | ios_base::trunc;
}
break;
}
if (sqlite_flag) {
return (sqlite3_open_v2 (filename.c_str (), &db_file, sqlite_code, 0) == SQLITE_OK);
} else {
if (File_Format () == BINARY) {
code |= ios_base::binary;
}
file.open (filename.c_str (), code);
return (file.is_open ());
}
}
bool Arcview_File::Set_Projection (Projection_Data input, Projection_Data output)
{
if (!Projection::Set_Projection (input, output)) return (false);
if (File_Access () == CREATE) {
Write_Projection ();
}
return (true);
}
bool Db_File::Filename (string rootname)
{
part_flag = false;
extend = 0;
if (rootname == filename) return (true);
filename.clear ();
pathname.clear ();
if (rootname.empty ()) return (false);
filename = rootname;
//---- check for a partition type ----
size_t index = filename.find (".*");
if (index != filename.npos) {
part_flag = true;
filename.erase (index);
if (f_exist (filename + ".AA")) {
Version (40);
extend = 1;
} else if (f_exist (filename + ".tAA")) {
Version (40);
extend = 2;
}
} else {
index = filename.find (".t*");
if (index != filename.npos) {
part_flag = true;
filename.erase (index);
if (f_exist (filename + ".tAA")) {
Version (40);
extend = 2;
}
} else {
part_flag = false;
}
}
if (part_flag) {
if (exe->Single_Partition ()) {
filename += Extension (exe->First_Partition ());
part_flag = false;
extend = 3;
}
} else if (exe->MPI_Size () > 1 && exe->Slave () && File_Access () == CREATE) {
filename += String (".%d") % exe->MPI_Rank ();
}
pathname = filename;
return (Filename (0));
}
void Db_File::Initialize (Access_Type access, Format_Type format)
{
db_file = 0;
insert_stmt = insert_nest = 0;
read_stmt = read_nest = 0;
first_offset = 0;
num_files = num_records = record_num = max_record_num = parent_id = part_num = extend = 0;
new_nest_flag = first_open = clean_flag = true;
part_flag = false;
Version (VERSION_CODE);
File_Access (access);
File_Format (format);
switch (format) {
default:
File_Type ("Text File");
break;
case BINARY:
File_Type ("Binary File");
break;
case FIXED_COLUMN:
File_Type ("Fixed Column File");
break;
case COMMA_DELIMITED:
File_Type ("Comma Delimited File");
break;
case SPACE_DELIMITED:
File_Type ("Space Delimited File");
break;
case VERSION3:
case TAB_DELIMITED:
File_Type ("Tab Delimited File");
break;
case CSV_DELIMITED:
File_Type ("CSV Delimited File");
break;
case DBASE:
File_Type ("dBase File");
break;
case ARCVIEW:
File_Type ("ArcView File");
break;
case SQLITE3:
File_Type ("SQLite3 Database");
break;
case TPPLUS:
File_Type ("TPPlus Matrix");
break;
case TRANSCAD:
File_Type ("TransCAD Matrix");
break;
}
}
void Tour_File::Setup (void)
{
if (File_Access () == CREATE) {
File_Type ("New Tour Data File");
File_ID ("NewTour");
} else {
File_Type ("Tour Data File");
File_ID ("Tour");
}
hhold = person = tour = purpose = mode = origin = destination = stop_out = stop_in = start = end = group = 0;
}
bool Snapshot_File::Open (string filename)
{
if (filename.empty ()) {
filename = Filename ();
}
if (filename.empty ()) return (false);
File_Type (File_Type ());
File_Access (File_Access ());
//---- open the snapshot file ----
bool status = Db_Header::Open (filename);
//---- set up and open the index file ----
if (compress) {
bool messages;
messages = exe->Send_Messages ();
exe->Send_Messages (false);
index_file.File_Type (File_Type () + " Index");
index_file.File_Access (File_Access ());
index_file.File_Format (BINARY);
filename += ".idx";
status = index_file.Open (filename);
index_file.Record_Size (sizeof (Index_Record));
index = (Index_Record *) index_file.Record_String ();
exe->Send_Messages (messages);
}
if (!status) return (Status (NOT_OPEN));
return (status);
}
void Arcview_File::Z_Flag (bool flag)
{
if (z_flag != flag) {
z_flag = flag;
if (File_Access () == CREATE) M_Flag (z_flag);
if (z_flag) {
int number = Max_Points ();
points.Z_Flag (z_flag);
if (number > 0) {
Max_Points (number);
}
}
}
}
bool Skim_File::Set_Field_Numbers (void)
{
Matrix_File::Set_Field_Numbers ();
//---- optional fields ----
count = Optional_Field ("COUNT");
time = Optional_Field (TIME_SKIM_FIELD_NAMES);
walk = Optional_Field (WALK_SKIM_FIELD_NAMES);
drive = Optional_Field (DRIVE_SKIM_FIELD_NAMES);
transit = Optional_Field (TRANSIT_SKIM_FIELD_NAMES);
wait = Optional_Field (WAIT_SKIM_FIELD_NAMES);
other = Optional_Field (OTHER_SKIM_FIELD_NAMES);
cost = Optional_Field (COST_SKIM_FIELD_NAMES);
length = Optional_Field (LENGTH_SKIM_FIELD_NAMES);
impedance = Optional_Field (IMP_SKIM_FIELD_NAMES);
if (File_Access () != CREATE) Total_Time_Flag ((time >= 0));
//---- set default units ----
if (Version () <= 40) {
Set_Units (time, SECONDS);
Set_Units (walk, SECONDS);
Set_Units (drive, SECONDS);
Set_Units (transit, SECONDS);
Set_Units (wait, SECONDS);
Set_Units (other, SECONDS);
Set_Units (cost, CENTS);
Set_Units (length, METERS);
Set_Units (impedance, IMPEDANCE);
} else {
Set_Units (time, SECONDS);
Set_Units (walk, SECONDS);
Set_Units (drive, SECONDS);
Set_Units (transit, SECONDS);
Set_Units (wait, SECONDS);
Set_Units (other, SECONDS);
Set_Units (cost, CENTS);
Set_Units (length, FEET);
Set_Units (impedance, IMPEDANCE);
}
return (true);
}
bool TransCAD_Matrix::Db_Open (string filename)
{
int i;
DATA_TYPE data_type;
if (!Load_DLL ()) return (Status (NO_TRANSCAD));
Set_Field_Numbers ();
if (File_Access () == CREATE) {
int len;
char **core_names;
Db_Field *fld_ptr;
if (Num_Des () == 0 || Tables () == 0) return (false);
if (Type () == DB_DOUBLE) {
data_type = DOUBLE_TYPE;
} else if (Type () == DB_FLOAT) {
data_type = FLOAT_TYPE;
} else if (Type () == DB_SHORT) {
data_type = SHORT_TYPE;
} else {
data_type = LONG_TYPE;
}
core_names = new char * [Tables ()];
for (i=0; i < Tables (); i++) {
fld_ptr = Table_Field (i);
len = (int) fld_ptr->Name ().length () + 1;
core_names [i] = new char [len];
strcpy_s (core_names [i], len, fld_ptr->Name ().c_str ());
}
if ((int) Org_Map ()->size () != Num_Org () || (int) Des_Map ()->size () != Num_Des ()) {
for (i=1; i <= Num_Org (); i++) {
Add_Org (i);
}
for (i=1; i <= Num_Des (); i++) {
Add_Des (i);
}
fh = MATRIX_New ((char *) filename.c_str (), (char *) File_Type ().c_str (),
Num_Org (), 0, Num_Des (), 0, Tables (), core_names, data_type, 1);
} else {
int i;
Integers row_ids, col_ids;
Int_Map_Itr map_itr;
row_ids.assign (Num_Org (), 0);
for (i=0, map_itr = Org_Map ()->begin (); map_itr != Org_Map ()->end (); map_itr++, i++) {
row_ids [i] = map_itr->first;
}
col_ids.assign (Num_Des (), 0);
for (i=0, map_itr = Des_Map ()->begin (); map_itr != Des_Map ()->end (); map_itr++, i++) {
col_ids [i] = map_itr->first;
}
fh = MATRIX_New ((char *) filename.c_str (), (char *) File_Type ().c_str (),
Num_Org (), (long *) &row_ids [0], Num_Des (), (long *) &col_ids [0],
Tables (), core_names, data_type, 1);
}
for (i=0; i < Tables (); i++) {
delete [] core_names [i];
}
delete [] core_names;
} else {
fh = MATRIX_LoadFromFile ((char *) filename.c_str (), CONTROL_AUTOMATIC);
if (tc_status != TC_OKAY || fh == 0) return (false);
Num_Org (MATRIX_GetNRows (fh));
Num_Des (MATRIX_GetNCols (fh));
data_type = MATRIX_GetDataType (fh);
if (data_type == DOUBLE_TYPE) {
Type (DB_DOUBLE);
} else if (data_type == FLOAT_TYPE) {
Type (DB_FLOAT);
} else if (data_type == SHORT_TYPE) {
Type (DB_SHORT);
} else {
Type (DB_INTEGER);
}
Tables (MATRIX_GetNCores (fh));
Integers ids;
ids.assign (Num_Org (), 0);
MATRIX_GetIDs(fh, MATRIX_ROW, (long *) &(ids [0]));
for (i=0; i < Num_Org (); i++) {
Add_Org (ids [i]);
}
ids.assign (Num_Des (), 0);
MATRIX_GetIDs(fh, MATRIX_COL, (long *) &(ids [0]));
for (i=0; i < Num_Des (); i++) {
Add_Des (ids [i]);
}
}
return (true);
}
bool Db_File::Open (string path)
{
if (!path.empty ()) {
Filename (path);
} else if (filename.empty ()) {
return (false);
}
if (Is_Open ()) {
Close ();
} else if (File_Format () == DEFAULT_FORMAT) {
File_Format (DEFAULT_FORMAT);
}
bool create_flag, exist_flag;
if (File_Access () == CREATE) {
create_flag = true;
exist_flag = f_exist (filename);
num_records = record_num = max_record_num = 0;
} else {
create_flag = exist_flag = false;
}
if (!Db_Open (filename)) {
if (exe->Send_Messages ()) {
string message (((create_flag) ? "Creating " : "Opening "));
message += File_Type ();
exe->File_Error (message, filename);
}
return (Status (NOT_OPEN));
} else {
if (create_flag && !File_Type ().Starts_With ("New") && !File_Type ().Starts_With ("Output")) {
File_Type (String ("New %s") % File_Type ());
if (File_Format () != SQLITE3) {
File_ID (String ("New%s") % File_ID ());
}
}
//---- first open processing ----
if (first_open) {
string name;
num_files = 1;
//---- print the filename ----
if (exe->Send_Messages ()) {
if (!part_flag) {
name = filename;
} else {
name = pathname + ".*";
part_num = 0;
}
exe->Print_Filename (1, File_Type (), name);
}
//---- delete existing files ----
if (exist_flag && part_flag) {
int num;
for (int part=1; part < 1000; part++) {
num = exe->Partition_Number (part);
if (num < 0) break;
name = pathname + Extension (num);
if (!f_exist (name)) break;
remove (name.c_str ());
name += ".def";
remove (name.c_str ());
}
}
}
if (File_Format () == SQLITE3) {
if (sqlite3_exec (db_file, "PRAGMA synchronous = OFF", 0, 0, 0) != SQLITE_OK) {
return (Status (NOT_OPEN));
}
}
return (Status (OK));
}
}
bool Plan_File::Read (long offset)
{
//---- check the file status ----
if (!Check_File ()) return (false);
if (plan == NULL) return (Status (RECORD_SIZE));
if (File_Access () != READ) return (Status (ERROR));
//---- move to a specified location in the file ----
if (offset >= 0) {
if (!Offset (offset)) return (false);
}
//---- allocate space ----
if (allocate_memory) {
if (!Setup_Record ()) return (false);
}
//---- read the next plan ----
if (Record_Format () == BINARY) {
int num_token;
if (!Db_File::Read (plan, (sizeof (Plan_Data) - sizeof (int)))) return (false);
if (time_sort) {
int temp = plan->key1;
plan->key1 = plan->key2;
plan->key2 = temp;
}
num_record++;
num_plan++;
if (Leg () == 2) {
num_trip++;
} else if (Leg () == 1 && Trip () == 1) {
num_traveler++;
}
num_token = Tokens ();
if (num_token > 0) {
if (!Check_Size (num_token)) return (false);
if (!Db_File::Read (&(plan->data [0]), num_token * sizeof (int))) return (Status (PLAN_FIELDS));
num_record++;
}
return (true);
} else {
int field, max_field, value;
char buffer [40], *ptr;
field = max_field = 0;
while (Db_File::Read ()) {
num_record++;
ptr = Clean_Record ();
//---- check for a blank record ----
if (ptr == NULL || *ptr == '\0') continue;
//---- process the plan record ----
while (ptr != NULL) {
ptr = Get_Token (ptr, buffer, sizeof (buffer));
if (buffer [0] == '\0') break;
field++;
value = atol (buffer);
switch (field) {
case 1: //---- traveler id ----
Traveler (value);
num_plan++;
break;
case 2: //---- user field ----
break;
case 3: //---- trip id ----
Trip (value);
break;
case 4: //---- leg id ----
Leg (value);
if (value == 2) {
num_trip++;
} else if (value == 1 && Trip () == 1) {
num_traveler++;
}
break;
case 5: //---- time ----
Time (value);
break;
case 6: //---- start id ----
Start_ID (value);
break;
case 7: //---- start type ----
Start_Type (value);
break;
case 8: //---- end id ----
End_ID (value);
break;
case 9: //---- end type ----
End_Type (value);
break;
case 10: //---- duration ----
Duration (value);
break;
case 11: //---- stop time ----
Stop_Time (value);
break;
case 12: //---- max time flag ----
break;
case 13: //---- cost ----
Cost (value);
break;
case 14: //---- gcf ----
GCF (value);
break;
case 15: //---- driver flag ----
Driver_Flag (value);
break;
case 16: //---- mode ----
Mode (value);
break;
case 17: //---- number of tokens ----
if (value < 0) {
Status (PLAN_FIELDS);
return (false);
}
Tokens (value);
max_field = value + 17;
if (value == 0) return (true);
if (!Check_Size (value)) return (false);
break;
default: //---- token value ----
if (field > max_field) {
Status (PLAN_FIELDS);
return (false);
}
plan->data [field - 18] = value;
if (field == max_field) return (true);
break;
}
}
}
if (field != 0) {
return (Status (PLAN_FIELDS));
}
return (false);
}
}
bool Plan_File::Write (Plan_Data *data)
{
int num_token;
FILE *file;
//---- check the file status ----
if (!Check_File ()) return (false);
if (File_Access () == READ) return (Status (ERROR));
Plan_Data *backup = NULL;
if (data != NULL) {
backup = plan;
plan = data;
} else {
if (plan == NULL) return (Status (RECORD_SIZE));
}
//---- write the plan data ----
file = File ();
num_token = Tokens ();
if (Record_Format () == BINARY) {
if (time_sort) {
int size, temp;
size = sizeof (Plan_Data) - sizeof (int);
memcpy (backup, plan, size);
temp = backup->key1;
backup->key1 = backup->key2;
backup->key2 = temp;
if (!Db_File::Write (backup, size)) goto reset;
} else {
if (!Db_File::Write (plan, (sizeof (Plan_Data) - sizeof (int)))) goto reset;
}
num_record++;
num_plan++;
if (Leg () == 2) {
num_trip++;
} else if (Leg () == 1 && Trip () == 1) {
num_traveler++;
}
if (num_token > 0) {
if (!Db_File::Write (&(plan->data [0]), num_token * sizeof (int))) goto reset;
num_record++;
}
} else {
if (fprintf (file, "%d 0 %d %d\n%d %d %d %d %d\n%d %d %d %d %d\n%d %d\n%d\n",
Traveler (), Trip (), Leg (),
Time (), Start_ID (), Start_Type (), End_ID (), End_Type (),
Duration (), Stop_Time (), 1, Cost (), GCF (),
Driver_Flag (), Mode (),
num_token) < 0) goto reset;
num_record += 5;
num_plan++;
if (Leg () == 2) {
num_trip++;
} else if (Leg () == 1 && Trip () == 1) {
num_traveler++;
}
//---- write tokens ----
if (num_token > 0) {
int field;
int i = 0;
switch (Mode ()) {
case AUTO_MODE: //---- auto ----
if (Driver_Flag ()) {
//---- vehicle ID and number of passengers ----
i = 2;
if (fprintf (file, "%d %d\n", plan->data [0], plan->data [1]) < 0) goto reset;
num_record++;
}
break;
case TRANSIT_MODE: //---- transit ----
if (Driver_Flag ()) {
//---- schedule pairs, vehicle ID, and route ID ----
i = 3;
if (fprintf (file, "%d %d %d\n", plan->data [0], plan->data [1], plan->data [2]) < 0) goto reset;
num_record++;
}
break;
default:
break;
}
//---- print the rest of the fields in groups of 10 ----
for (field=0; i < num_token; i++, field++) {
if (!field) {
if (fprintf (file, "%d", plan->data [i]) < 0) goto reset;
num_record++;
} else if (!(field % 10)) {
if (fprintf (file, "\n%d", plan->data [i]) < 0) goto reset;
num_record++;
} else {
if (fprintf (file, " %d", plan->data [i]) < 0) goto reset;
}
}
if (field) {
if (fprintf (file, "\n") < 0) goto reset;
}
}
//---- add a blank line at the end of the plan ----
if (fprintf (file, "\n") < 0) goto reset;
num_record++;
Flush ();
}
if (data != NULL) {
plan = backup;
}
return (true);
reset:
if (data != NULL) {
plan = backup;
}
return (false);
}
bool Arcview_File::Open (char *filename)
{
int n;
char pathname [FILE_NAME_SIZE];
bool messages, status;
if (filename == NULL) {
filename = Filename ();
if (filename == NULL) return (false);
}
str_cpy (pathname, sizeof (pathname), filename);
messages = Send_Messages ();
Send_Messages (false);
shape_file.File_Type (File_Type ());
shape_file.File_Access (File_Access ());
index_file.File_Type (File_Type ());
index_file.File_Access (File_Access ());
index_file.Send_Messages (false);
//---- open the shape file ----
if (!shape_file.Open (pathname)) {
return (Status (NOT_OPEN));
}
if (File_Access () == CREATE) {
Write_Projection ();
switch (Shape_Type ()) {
case DOT:
shape_header.shape_type = POINT_TYPE;
break;
case MDOTS:
shape_header.shape_type = MULTIPOINT_TYPE;
break;
case LINE:
case VECTOR:
shape_header.shape_type = ARC_TYPE;
break;
case POLYGON:
shape_header.shape_type = POLYGON_TYPE;
break;
default:
break;
}
if (Z_Flag () || M_Flag ()) {
if (!Z_Flag ()) {
Z_Flag (true);
}
shape_header.shape_type += (M_Flag ()) ? 20 : 10;
}
shape_header.file_size = sizeof (shape_header) / sizeof (short);
shape_header.box.xmin = shape_header.box.ymin = -NAN;
shape_header.box.xmax = shape_header.box.ymax = NAN;
if (Z_Flag ()) {
shape_header.zbox.min = shape_header.mbox.min = -NAN;
shape_header.zbox.max = shape_header.mbox.max = NAN;
}
Reorder_Bits (&shape_header, 7);
if (!shape_file.Write (&shape_header, sizeof (shape_header), 0L)) {
return (Status (HEADER_WRITE));
}
} else {
if (!shape_file.Read (&shape_header, sizeof (shape_header), 0L)) {
return (Status (HEADER_READ));
}
}
Reorder_Bits (&shape_header, 7);
switch ((shape_header.shape_type % 10)) {
case POINT_TYPE: //---- point ----
Shape_Type (DOT);
break;
case MULTIPOINT_TYPE: //---- multipoint ----
Shape_Type (MDOTS);
break;
case ARC_TYPE: //---- arc ----
Shape_Type (VECTOR);
break;
case POLYGON_TYPE: //---- polygon ----
Shape_Type (POLYGON);
break;
default:
return (Status (HEADER_READ));
}
Z_Flag ((shape_header.shape_type / 10) > 0);
M_Flag ((shape_header.shape_type / 10) == 2);
extent.xmin = shape_header.box.xmin;
extent.ymin = shape_header.box.ymin;
extent.xmax = shape_header.box.xmax;
extent.ymax = shape_header.box.ymax;
Convert (&(extent.xmin), &(extent.ymin));
Convert (&(extent.xmax), &(extent.ymax));
if (M_Flag ()) {
_extent.min = shape_header.mbox.min;
_extent.max = shape_header.mbox.max;
} else if (Z_Flag ()) {
_extent.min = shape_header.zbox.min;
_extent.max = shape_header.zbox.max;
}
shape_file.First_Offset (sizeof (shape_header));
shape_file.Record_Size (sizeof (Arc_Record));
Num_Points (1);
Num_Parts (1);
//---- open the index file ----
n = (int) strlen (pathname);
memcpy (pathname + n - 3, "shx", 3);
if (!index_file.Open (pathname)) {
return (Status (NOT_OPEN));
}
if (File_Access () == CREATE) {
index_header.file_size = sizeof (index_header) / sizeof (short);
Reorder_Bits (&index_header, 7);
if (!index_file.Write (&index_header, sizeof (index_header), 0L)) {
return (Status (HEADER_WRITE));
}
//---- delete ArcGIS spatial index files ----
memcpy (pathname + n - 3, "sbn", 3);
remove (pathname);
memcpy (pathname + n - 3, "sbx", 3);
remove (pathname);
//---- remove uDig support files ----
memcpy (pathname + n - 3, "qix", 3);
remove (pathname);
memcpy (pathname + n - 3, "fix", 3);
remove (pathname);
} else {
if (!index_file.Read (&index_header, sizeof (index_header), 0L)) {
return (Status (HEADER_READ));
}
}
Reorder_Bits (&index_header, 7);
index_file.First_Offset (sizeof (index_header));
index_file.Record_Size (sizeof (Arc_Record));
//---- open the dbase file ----
memcpy (pathname + n - 3, "dbf", 3);
status = Db_Header::Open (pathname);
Send_Messages (messages);
index_file.Send_Messages (messages);
return (status);
}
int Db_Base::Add_Field (const char *name, Field_Type type, double size, Units_Type units, bool binary, Nest_Type nest, int offset)
{
if (Dbase_Format () == DEFAULT_FORMAT) {
Dbase_Format (DEFAULT_FORMAT);
}
if (field.capacity () == 0) {
field.reserve (10);
}
if (time_format == NO_UNITS) {
time_format = Static_Service::Time_Format ();
if (type == DB_TIME && units == NO_UNITS) {
units = time_format;
}
}
int length, num;
Field_Itr itr;
switch (Dbase_Format ()) {
case COMMA_DELIMITED:
case SPACE_DELIMITED:
case TAB_DELIMITED:
case CSV_DELIMITED:
case VERSION3:
num = 1;
length = 0;
for (itr = field.begin (); itr != field.end (); itr++) {
if ((nest != NESTED && !itr->Nested ()) || itr->Nest () == nest) {
length += itr->Width () + 1;
num++;
}
}
if (binary) {
Binary_Text_Size (type, &size);
}
length += (int) size;
if (offset <= 0) offset = num;
break;
case UNFORMATED:
case BINARY:
case FIXED_COLUMN:
case DBASE:
case ARCVIEW:
case SQLITE3:
case TPPLUS:
case TRANSCAD:
default:
if (offset < 0) {
offset = (Dbase_Format () == DBASE || Dbase_Format () == ARCVIEW) ? 1 : 0;
for (itr = field.begin (); itr != field.end (); itr++) {
if ((nest != NESTED && !itr->Nested ()) || itr->Nest () == nest) {
length = itr->Offset () + itr->Width ();
if (offset < length) offset = length;
}
}
}
if (binary) {
if (Record_Format () != BINARY) {
Binary_Text_Size (type, &size);
}
} else if (Record_Format () == BINARY) {
Text_Binary_Size (type, &size);
}
if (type == DB_TIME && Record_Format () == BINARY) {
units = SECONDS;
}
length = offset + (int) size;
break;
}
//---- convert to internal units ----
if (File_Access () == CREATE) Internal_Units (1.0, &units);
Db_Field fld (name, type, offset, size, units, nest);
num = (int) field.size ();
field.push_back (fld);
Nested (nest);
if (!Record_Size (length)) return (-1);
return (num);
}
bool TPPlus_Matrix::Db_Open (string filename)
{
int i, type;
char *license = 0;
if (!Load_DLL ()) return (Status (NO_TPPLUS));
Set_Field_Numbers ();
if (File_Access () == CREATE) {
int len;
unsigned char *header;
Db_Field *fld_ptr;
if (Num_Des () == 0 || Tables () == 0) return (false);
if (Dbase_Format () == TRANPLAN) {
type = TPLAN;
} else {
type = TPP;
}
TppMatMatSet (&fh, type, (char *) filename.c_str (), Num_Des (), Tables ());
header = fh->Mnames;
for (i=0; i < Tables (); i++) {
fld_ptr = Table_Field (i);
if (fld_ptr->Decimal () == 0) {
fh->Mspecs [i] = 'D';
} else {
fh->Mspecs [i] = (unsigned char) fld_ptr->Decimal ();
}
len = (int) fld_ptr->Name ().length () + 1;
memcpy (header, fld_ptr->Name ().c_str (), len);
header += len;
}
if ((i = TppMatOpenOP (fh, (char *) File_ID ().c_str (), (char *) exe->Program (), 0, license, CUBE)) <= 0) {
if (i < -1) {
return (Status (TPPLUS_LICENSE));
} else {
return (false);
}
}
TppMatMatResize (&fh);
} else {
if (FileInquire ((char *) filename.c_str (), &fh) <= 0) return (false);
if ((i = TppMatOpenIP (fh, license, CUBE)) <= 0) {
if (i < -1) {
return (Status (TPPLUS_LICENSE));
} else {
return (false);
}
}
Num_Org (fh->zones);
Num_Des (fh->zones);
Tables (fh->mats);
}
for (i=1; i <= Num_Des (); i++) {
Add_Org (i);
Add_Des (i);
}
fh->buffer = (void *) new char [fh->bufReq];
return (true);
}
