IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5216 for trunk/psLib/src


Ignore:
Timestamp:
Sep 30, 2005, 4:22:26 PM (21 years ago)
Author:
desonia
Message:

changed psArrayGet/psArraySet/psArrayRemove to do proper reference counting.

Location:
trunk/psLib/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/Makefile.am

    r4981 r5216  
    55libpslib_la_CPPFLAGS = $(SRCINC)
    66libpslib_la_LIBADD = $(SRCSUBLIBS)
     7libpslib_la_DEPENDENCIES = $(SRCSUBLIBS)
    78
    89libpslib_la_SOURCES = psTest.c

  • trunk/psLib/src/db/psDB.c

    r5136 r5216  
    1212 *  @author Joshua Hoblitt
    1313 *
    14  *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-09-26 21:13:16 $
     14 *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-10-01 02:22:09 $
    1616 *
    1717 *  Copyright 2005 Joshua Hoblitt, University of Hawaii
    … …  
    4343}
    4444mysqlType;
     45
     46static psHash   *pTypeToSQLlookupTable = NULL;
     47static psHash   *sqlToPTypeLookupTable = NULL;
     48static psHash   *mysqlToSqlLookupTable = NULL;
     49static psHash   *pTypeToMysqlLookupTable = NULL;
    4550
    4651// database utility functions
    … …  
    14211426static psHash *psDBGetPTypeToSQLTable(void)
    14221427{
    1423     static psHash   *lookupTable = NULL;
    1424 
    1425     if (!lookupTable) {
    1426         lookupTable = psHashAlloc(14);
     1428
     1429    if (!pTypeToSQLlookupTable) {
     1430        pTypeToSQLlookupTable = psHashAlloc(14);
    14271431
    14281432        // no support for CHAR, TEXT or GLOB
    1429         psDBAddToLookupTable(lookupTable, PS_TYPE_S8,  "TINYINT");
    1430         psDBAddToLookupTable(lookupTable, PS_TYPE_S16, "SMALLINT");
    1431         psDBAddToLookupTable(lookupTable, PS_TYPE_S32, "INT");
    1432         psDBAddToLookupTable(lookupTable, PS_TYPE_S64, "BIGINT");
    1433         psDBAddToLookupTable(lookupTable, PS_TYPE_U8,  "UNSIGNED TINYINT");
    1434         psDBAddToLookupTable(lookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT");
    1435         psDBAddToLookupTable(lookupTable, PS_TYPE_U32, "UNSIGNED INT");
    1436         psDBAddToLookupTable(lookupTable, PS_TYPE_U64, "UNSIGNED BIGINT");
    1437         psDBAddToLookupTable(lookupTable, PS_TYPE_F32, "FLOAT");
    1438         psDBAddToLookupTable(lookupTable, PS_TYPE_F64, "DOUBLE");
    1439         psDBAddToLookupTable(lookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
    1440         psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
    1441         psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"TINYINT");
    1442         psDBAddToLookupTable(lookupTable, PS_DATA_STRING, "VARCHAR");
     1433        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S8,  "TINYINT");
     1434        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S16, "SMALLINT");
     1435        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S32, "INT");
     1436        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S64, "BIGINT");
     1437        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U8,  "UNSIGNED TINYINT");
     1438        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT");
     1439        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U32, "UNSIGNED INT");
     1440        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U64, "UNSIGNED BIGINT");
     1441        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_F32, "FLOAT");
     1442        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_F64, "DOUBLE");
     1443        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
     1444        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
     1445        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_BOOL,"TINYINT");
     1446        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_STRING, "VARCHAR");
    14431447    }
    14441448
    14451449    // simulate true ref counting
    1446     psMemIncrRefCounter(lookupTable);
    1447 
    1448     return lookupTable;
     1450    psMemIncrRefCounter(pTypeToSQLlookupTable);
     1451
     1452    return pTypeToSQLlookupTable;
    14491453}
    14501454
    14511455static void psDBPTypeToSQLTableCleanup(void)
    14521456{
    1453     psHash          *lookupTable;
    1454 
    1455     lookupTable = psDBGetPTypeToSQLTable();
    1456 
    1457     psMemDecrRefCounter(lookupTable);
    1458     psFree(lookupTable);
     1457    psFree(pTypeToSQLlookupTable);
     1458    pTypeToSQLlookupTable = NULL;
    14591459}
    14601460
    14611461static psHash *psDBGetSQLToPTypeTable(void)
    14621462{
    1463     static psHash   *lookupTable = NULL;
    14641463    psHash          *psToSQLTable;
    14651464    psList          *list;
    … …  
    14681467    char            *value;
    14691468
    1470     if (!lookupTable) {
     1469    if (!sqlToPTypeLookupTable) {
    14711470        // invert the PSToSQL table
    14721471        psToSQLTable = psDBGetPTypeToSQLTable();
    1473         lookupTable = psHashAlloc(psToSQLTable->n);
     1472        sqlToPTypeLookupTable = psHashAlloc(psToSQLTable->n);
    14741473
    14751474        list = psHashKeyList(psToSQLTable);
    … …  
    14791478            value = psHashLookup(psToSQLTable, key);
    14801479            // switch key and value
    1481             psHashAdd(lookupTable, value, key);
     1480            psHashAdd(sqlToPTypeLookupTable, value, key);
    14821481        }
    14831482
    14841483        // Add BLOB & TEXT reverse mappings
    14851484        value = psDBIntToString((psU64)PS_DATA_STRING);
    1486         psHashAdd(lookupTable, "BLOB",    value);
    1487         psHashAdd(lookupTable, "TEXT",    value);
     1485        psHashAdd(sqlToPTypeLookupTable, "BLOB",    value);
     1486        psHashAdd(sqlToPTypeLookupTable, "TEXT",    value);
    14881487        psFree(value);
    14891488
    14901489        // DECIMAL does not exist in the pType to SQL table
    14911490        value = psDBIntToString(0);
    1492         psHashAdd(lookupTable, "DECIMAL", value);
     1491        psHashAdd(sqlToPTypeLookupTable, "DECIMAL", value);
    14931492        psFree(value);
    14941493
    … …  
    14991498
    15001499    // simulate true ref counting
    1501     psMemIncrRefCounter(lookupTable);
    1502 
    1503     return lookupTable;
     1500    psMemIncrRefCounter(sqlToPTypeLookupTable);
     1501
     1502    return sqlToPTypeLookupTable;
    15041503}
    15051504
    15061505static void psDBSQLToPTypeTableCleanup(void)
    15071506{
    1508     psHash          *lookupTable;
    1509 
    1510     lookupTable = psDBGetSQLToPTypeTable();
    1511 
    1512     psMemDecrRefCounter(lookupTable);
    1513     psFree(lookupTable);
     1507    psFree(sqlToPTypeLookupTable);
     1508    sqlToPTypeLookupTable = NULL;
    15141509}
    15151510
    15161511static psHash *psDBGetMySQLToSQLTable(void)
    15171512{
    1518     static psHash   *lookupTable = NULL;
    1519 
    1520     if (!lookupTable) {
    1521         lookupTable = psHashAlloc(20);
    1522 
    1523         psDBAddToLookupTable(lookupTable, FIELD_TYPE_TINY,      "TINYINT");
    1524         psDBAddToLookupTable(lookupTable, FIELD_TYPE_SHORT,     "SMALLINT");
    1525         psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONG,      "INT");
    1526         psDBAddToLookupTable(lookupTable, FIELD_TYPE_INT24,     "MEDIUMINT");
    1527         psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONGLONG,  "BIGINT");
    1528         psDBAddToLookupTable(lookupTable, FIELD_TYPE_DECIMAL,   "DECIMAL");
    1529         psDBAddToLookupTable(lookupTable, FIELD_TYPE_FLOAT,     "FLOAT");
    1530         psDBAddToLookupTable(lookupTable, FIELD_TYPE_DOUBLE,    "DOUBLE");
    1531         psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP");
    1532         psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATE,      "DATE");
    1533         psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIME,      "TIME");
    1534         psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATETIME,  "DATETIME");
    1535         psDBAddToLookupTable(lookupTable, FIELD_TYPE_YEAR,      "YEAR");
    1536         psDBAddToLookupTable(lookupTable, FIELD_TYPE_STRING,    "CHAR");
    1537         psDBAddToLookupTable(lookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR");
    1538         psDBAddToLookupTable(lookupTable, FIELD_TYPE_BLOB,      "BLOB");
    1539         psDBAddToLookupTable(lookupTable, FIELD_TYPE_SET,       "SET");
    1540         psDBAddToLookupTable(lookupTable, FIELD_TYPE_ENUM,      "ENUM");
    1541         psDBAddToLookupTable(lookupTable, FIELD_TYPE_NULL,      "NULL-type");
    1542         psDBAddToLookupTable(lookupTable, FIELD_TYPE_CHAR,      "TINYINT");
     1513    if (!mysqlToSqlLookupTable) {
     1514        mysqlToSqlLookupTable = psHashAlloc(20);
     1515
     1516        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_TINY,      "TINYINT");
     1517        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_SHORT,     "SMALLINT");
     1518        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_LONG,      "INT");
     1519        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_INT24,     "MEDIUMINT");
     1520        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_LONGLONG,  "BIGINT");
     1521        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DECIMAL,   "DECIMAL");
     1522        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_FLOAT,     "FLOAT");
     1523        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DOUBLE,    "DOUBLE");
     1524        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP");
     1525        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DATE,      "DATE");
     1526        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_TIME,      "TIME");
     1527        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DATETIME,  "DATETIME");
     1528        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_YEAR,      "YEAR");
     1529        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_STRING,    "CHAR");
     1530        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR");
     1531        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_BLOB,      "BLOB");
     1532        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_SET,       "SET");
     1533        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_ENUM,      "ENUM");
     1534        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_NULL,      "NULL-type");
     1535        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_CHAR,      "TINYINT");
    15431536    }
    15441537
    15451538    // simulate true ref counting
    1546     psMemIncrRefCounter(lookupTable);
    1547 
    1548     return lookupTable;
     1539    psMemIncrRefCounter(mysqlToSqlLookupTable);
     1540
     1541    return mysqlToSqlLookupTable;
    15491542}
    15501543
    15511544static void psDBMySQLToSQLTableCleanup(void)
    15521545{
    1553     psHash          *lookupTable;
    1554 
    1555     lookupTable = psDBGetMySQLToSQLTable();
    1556 
    1557     psMemDecrRefCounter(lookupTable);
    1558     psFree(lookupTable);
     1546    psFree(mysqlToSqlLookupTable);
     1547    mysqlToSqlLookupTable = NULL;
    15591548}
    15601549
    15611550static psHash *psDBGetPTypeToMySQLTable(void)
    15621551{
    1563     static psHash   *lookupTable = NULL;
    1564 
    1565     if (!lookupTable) {
    1566         lookupTable = psHashAlloc(14);
    1567 
    1568         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       false));
    1569         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      false));
    1570         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       false));
    1571         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   false));
    1572         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
    1573         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      true));
    1574         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       true));
    1575         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   true));
    1576         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_F32,    psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT,      false));
    1577         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_F64,    psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE,     false));
     1552    if (!pTypeToMysqlLookupTable) {
     1553        pTypeToMysqlLookupTable = psHashAlloc(14);
     1554
     1555        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       false));
     1556        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      false));
     1557        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       false));
     1558        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   false));
     1559        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
     1560        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      true));
     1561        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       true));
     1562        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   true));
     1563        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_F32,    psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT,      false));
     1564        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_F64,    psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE,     false));
    15781565        // bogus type
    1579         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_C32,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1566        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C32,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    15801567        // bogus type
    1581         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_C64,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1582         psDBAddVoidToLookupTable(lookupTable, PS_TYPE_BOOL,   psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
     1568        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C64,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1569        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_BOOL,   psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
    15831570        // XXX: removed PS_TYPE_PTR, can this be removed too?
    1584         // psDBAddVoidToLookupTable(lookupTable, PS_TYPE_PTR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1585 
    1586         psDBAddVoidToLookupTable(lookupTable, PS_DATA_STRING,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1587         psDBAddVoidToLookupTable(lookupTable, PS_DATA_VECTOR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1588         psDBAddVoidToLookupTable(lookupTable, PS_DATA_IMAGE,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1589         psDBAddVoidToLookupTable(lookupTable, PS_DATA_HASH,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1590         psDBAddVoidToLookupTable(lookupTable, PS_DATA_LOOKUPTABLE,
     1571        // psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_PTR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1572
     1573        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_STRING,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1574        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_VECTOR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1575        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_IMAGE,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1576        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_HASH,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1577        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_LOOKUPTABLE,
    15911578                                 psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1592         //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_JPEG,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1593         //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_PNG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1594         //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_ASTROM, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    1595         psDBAddVoidToLookupTable(lookupTable, PS_DATA_UNKNOWN,psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1579        //        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_JPEG,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1580        //        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_PNG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1581        //        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_ASTROM, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     1582        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_UNKNOWN,psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
    15961583    }
    15971584
    15981585    // simulate true ref counting
    1599     psMemIncrRefCounter(lookupTable);
    1600 
    1601     return lookupTable;
     1586    psMemIncrRefCounter(pTypeToMysqlLookupTable);
     1587
     1588    return pTypeToMysqlLookupTable;
    16021589}
    16031590
    16041591static void psDBPTypeToMySQLTableCleanup(void)
    16051592{
    1606     psHash          *lookupTable;
    1607 
    1608     lookupTable = psDBGetPTypeToMySQLTable();
    1609 
    1610     psMemDecrRefCounter(lookupTable);
    1611     psFree(lookupTable);
     1593    psFree(pTypeToMysqlLookupTable);
     1594    pTypeToMysqlLookupTable = NULL;
    16121595}
    16131596

  • trunk/psLib/src/imageops/psImageStructManip.c

    r5057 r5216  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-09-15 21:22:22 $
     10 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-10-01 02:22:11 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9696        // if a child, need to orphan (disassociate from parent) first
    9797        if (out->parent != NULL) {
    98             psArrayRemove(out->parent->children,out); // remove from parent's knowledge
     98            psArrayRemove(out->parent->children,psMemIncrRefCounter(out));
     99            // remove from parent's knowledge without triggering a free
    99100            out->parent = NULL; // break link to parent
    100101        }
    … …  
    127128
    128129    // add output image as a child of the input image.
    129     psS32 n = 0;
    130     psArray* children = image->children;
    131     if (children == NULL) {
    132         children = psArrayAlloc(16); // start with a reasonable size for growth
    133     } else if (children->nalloc == children->n) { // full?
    134         n = children->n;
    135         children = psArrayRealloc(children,n*2); // double the array size
    136     } else {
    137         n = children->n;
    138     }
    139     children->data[n] = out;
    140     children->n = n+1;
    141     image->children = children; // push back any change (esp. if children==NULL before)
     130    image->children = psArrayAdd(image->children,16,out);
     131    psMemDecrRefCounter(out); // don't count the reference held by parent as a true reference
    142132
    143133    return (out);

  • trunk/psLib/src/mathtypes/psImage.c

    r5178 r5216  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.88 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-09-29 19:05:02 $
     11 *  @version $Revision: 1.89 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-10-01 02:22:12 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3939
    4040    if (image->parent != NULL) {
     41        psMemBlock* ptr = ((psMemBlock*)image)-1;
     42        int ref = ptr->refCounter;
     43        ptr->refCounter = 2;  // make sure psFree is not retriggered
    4144        psArrayRemove(image->parent->children,image);
     45        ptr->refCounter = ref; // restore previous count (not assuming zero, but should be)
     46
    4247        image->parent = NULL;
    4348    }

  • trunk/psLib/src/sys/psMemory.c

    r4971 r5216  
    88*  @author Robert Lupton, Princeton University
    99*
    10 *  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2005-09-08 00:17:26 $
     10*  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2005-10-01 02:22:13 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    583583}
    584584
     585psPtr p_psMemSetRefCounter(
     586    psPtr vptr,
     587    psReferenceCount count,
     588    const char *file,
     589    psS32 lineno)
     590{
     591    psMemBlock* ptr;
     592
     593    if (vptr == NULL) {
     594        return vptr;
     595    }
     596
     597    if (count < 0) {
     598        count = 0;
     599    }
     600
     601    ptr = ((psMemBlock* ) vptr) - 1;
     602
     603    if (checkMemBlock(ptr, __func__)) {
     604        memProblemCallback(ptr, file, lineno);
     605    }
     606
     607    pthread_mutex_lock(&ptr->refCounterMutex);
     608    ptr->refCounter = count;
     609    pthread_mutex_unlock(&ptr->refCounterMutex);
     610
     611    if (count < 1) {
     612        vptr = p_psMemDecrRefCounter(vptr,file,lineno);
     613    }
     614
     615    return vptr;
     616}
     617
    585618// decrement and return refCounter
    586619psPtr p_psMemDecrRefCounter(psPtr vptr,
    … …  
    707740    return PTR->freeFunc;
    708741}
    709 
    710742
    711743bool psMemCheckType(psDataType type,

  • trunk/psLib/src/sys/psMemory.h

    r4920 r5216  
    1212 *  @ingroup MemoryManagement
    1313 *
    14  *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-08-31 02:07:11 $
     14 *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-10-01 02:22:13 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    350350#endif // !DOXYGEN
    351351
     352/** Set reference counter and return the pointer
     353 *
     354 *  @ingroup memRefCount
     355 *
     356 *  @return psPtr    the pointer with refCount set, or NULL if pointer is
     357 *                   fully dereferenced.
     358 */
     359#ifdef DOXYGEN
     360psPtr psMemSetRefCounter(
     361    psPtr ptr,                        ///< Pointer to decrement refCounter, and return
     362    psReferenceCount count            ///< New reference count
     363);
     364#else // DOXYGEN
     365psPtr p_psMemSetRefCounter(
     366    psPtr vptr,                        ///< Pointer to decrement refCounter, and return
     367    psReferenceCount count,            ///< New reference count
     368    const char *file,                  ///< File of call
     369    psS32 lineno                       ///< Line number of call
     370);
     371
     372#ifndef SWIG
     373#define psMemSetRefCounter(vptr, count) p_psMemSetRefCounter(vptr, count, __FILE__, __LINE__)
     374#endif // !SWIG
     375
     376#endif // !DOXYGEN
     377
    352378/** Set callback for problems.
    353379 *

  • trunk/psLib/src/types/psArray.c

    r5114 r5216  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-09-24 00:17:44 $
     11 *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-10-01 02:22:15 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4141    }
    4242
    43     psArrayElementFree(psArr);
     43    psArrayElementsFree(psArr);
    4444
    4545    psFree(psArr->data);
    … …  
    9898{
    9999    if (array == NULL) {
    100         return array;
     100        int d = (delta > 0) ? delta : 10; // as spec'ed in SDRS.
     101        array = psArrayAlloc(d);
     102        array->n = 0;
    101103    }
    102104
    … …  
    132134        if (psArrData[i] == data) {
    133135            memmove(&array->data[i],&array->data[i+1],(n-i-1)*sizeof(psPtr));
     136            psFree(data); // free the removed item (see Bug #449)
    134137            n--;
    135138            success = true;
    … …  
    141144}
    142145
    143 void psArrayElementFree(psArray* psArr)
     146void psArrayElementsFree(psArray* psArr)
    144147{
    145148
    … …  
    205208    }
    206209    psFree(array->data[position]);
    207     array->data[position] = data;
     210    array->data[position] = psMemIncrRefCounter(data);
    208211
    209212    return true;
    … …  
    232235        return NULL;
    233236    }
    234     return array->data[position];
    235 }
    236 
    237 
    238 
    239 
     237    return psMemIncrRefCounter(array->data[position]);
     238}

  • trunk/psLib/src/types/psArray.h

    r5114 r5216  
    1 
    21/** @file  psArray.h
    32 *
    … …  
    1211 *  @author Ross Harman, MHPCC
    1312 *
    14  *  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-09-24 00:17:44 $
     13 *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-10-01 02:22:15 $
    1615 *
    1716 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    116115 *
    117116 */
    118 void psArrayElementFree(
     117void psArrayElementsFree(
    119118    psArray* psArr                     ///< Void pointer array to destroy.
    120119);

  • trunk/psLib/src/types/psList.c

    r5174 r5216  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-09-29 01:15:38 $
     8 *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-10-01 02:22:15 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4141    pthread_mutex_lock(&list->p_lock);
    4242
    43     // remove the free function of iterators to avoid double removal from list
     43    // remove the associated iterators -- any references are invalid once psList is freed.
    4444    psArray* iterators = list->iterators;
    45     for (int i = 0; i < iterators->n; i++) {
    46         psMemSetDeallocator(iterators->data[i], NULL);
    47     }
    48 
    49     psFree(list->iterators);
     45    // ONLY orphan the iterators if the list iterators are about to be destroyed
     46    // a case where this is not the case is in psListSort.
     47    if (psMemGetRefCounter(iterators)  < 2) {
     48        for (int i = 0; i < iterators->n; i++) {
     49            // orphan iterators first to avoid any callbacks to dying list
     50            ((psListIterator*)iterators->data[i])->list = NULL;
     51            // remove all external references
     52            psMemSetRefCounter(iterators->data[i], 1);
     53        }
     54    }
     55    psFree(iterators);
    5056
    5157    for (psListElem* ptr = list->head; ptr != NULL;) {
    … …  
    7177
    7278    // remove this iterator from the parent list
    73     psArrayRemove(iter->list->iterators,iter);
    74 
     79    if (iter->list != NULL) {
     80        psArray* iters = iter->list->iterators;
     81        for (int lcv = 0; lcv < iters->n; lcv++) {
     82            if (iters->data[lcv] == iter) {
     83                // following is done to match SDRS.
     84                iters->data[lcv] = iters->data[iters->n-1];
     85                iters->n--;
     86                break;
     87            }
     88        }
     89    }
    7590}
    7691
    … …  
    164179    iter->mutable = mutable;
    165180
    166     // add to the list's array of iterators
    167     psArray* listIterators = list->iterators;
    168     int num = listIterators->n;
    169     if ( num >= listIterators->nalloc) {
    170         // need to resize the array to make more room for another iterator.
    171         list->iterators = psArrayRealloc(listIterators,listIterators->nalloc*2);
    172         listIterators = list->iterators;
    173     }
    174     listIterators->data[num] = iter;
    175     listIterators->n = num+1;
     181    // associate the iterator with the list
     182    list->iterators = psArrayAdd(list->iterators,0,iter);
     183    // don't want the list's array of iterators to hold a true reference
     184    psMemDecrRefCounter(iter);
    176185
    177186    if (! psListIteratorSet(iter,location)) {
    178187        psFree(iter);
    179         iter = NULL;
     188        return NULL;
    180189    }
    181190

  • trunk/psLib/src/types/psMetadataConfig.c

    r5174 r5216  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-09-29 01:15:38 $
     12*  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-10-01 02:22:15 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    995995        nextLevelInfo->name = psStringCopy(keyName);
    996996        // Add next level to levelArray
    997         levelArray = psArrayAdd(levelArray,1,nextLevelInfo);
     997        levelArray = psArrayAdd(levelArray,0,nextLevelInfo);
    998998        psFree(nextLevelInfo);
    999999        // Increment level counter
    … …  
    11321132                        return false;
    11331133                    }
    1134                     psFree(lowerLevelInfo);
    11351134                    (*level)--;
    11361135                }
Note: See TracChangeset for help on using the changeset viewer.