/** * Helper function for destructing the HashTable pairs */ NITFPRIV(int) destructHashValue(nitf_HashTable * ht, nitf_Pair * pair, NITF_DATA* userData, nitf_Error * error) { if (pair) if (pair->data) nitf_Field_destruct((nitf_Field **) & pair->data); return NITF_SUCCESS; }
NITFPRIV(NITF_BOOL) defaultSetField(nitf_TRE * tre, const char *tag, NITF_DATA * data, size_t dataLength, nitf_Error * error) { nitf_Field* field = NULL; if (strcmp(tag, NITF_TRE_RAW)) { nitf_Error_initf(error, NITF_CTXT, NITF_ERR_INVALID_PARAMETER, "Invalid param [%s]", tag); return NITF_FAILURE; } field = nitf_Field_construct(dataLength, NITF_BINARY, error); if (!field) return NITF_FAILURE; /* TODO -- likely inefficient, since we end up copying the raw data here */ if (!nitf_Field_setRawData(field, (NITF_DATA *) data, dataLength, error)) return NITF_FAILURE; if (nitf_HashTable_exists(((nitf_TREPrivateData*)tre->priv)->hash, tag)) { nitf_Field* oldValue; nitf_Pair* pair = nitf_HashTable_find( ((nitf_TREPrivateData*)tre->priv)->hash, tag); oldValue = (nitf_Field*)pair->data; nitf_Field_destruct(&oldValue); pair->data = field; return NITF_SUCCESS; } /* reset the lengths in two places */ ((nitf_TREPrivateData*)tre->priv)->length = dataLength; ((nitf_TREPrivateData*)tre->priv)->description[0].data_count = dataLength; return nitf_HashTable_insert(((nitf_TREPrivateData*)tre->priv)->hash, tag, field, error); }
/*! * Clone this object. This is a deep copy operation. * * \param source The source object * \param error An error to populate upon failure * \return A new object that is identical to the old */ NITFAPI(nitf_Field *) nitf_Field_clone(nitf_Field * source, nitf_Error * error) { nitf_Field *field = NULL; if (source) { /* construct new one */ field = nitf_Field_construct(source->length, source->type, error); if (field) { field->resizable = source->resizable; /* set the data */ if (!nitf_Field_setRawData (field, (NITF_DATA *) source->raw, source->length, error)) { nitf_Field_destruct(&field); field = NULL; } } } return field; }
NITFAPI(nitf_Field *) nitf_Field_construct(size_t length, nitf_FieldType type, nitf_Error * error) { nitf_Field *field = NULL; if (length == 0) { nitf_Error_initf(error, NITF_CTXT, NITF_ERR_INVALID_PARAMETER, "Cannot create field of size 0"); goto CATCH_ERROR; } field = (nitf_Field *) NITF_MALLOC(sizeof(nitf_Field)); if (!field) { nitf_Error_init(error, NITF_STRERROR(NITF_ERRNO), NITF_CTXT, NITF_ERR_MEMORY); goto CATCH_ERROR; } field->type = type; field->raw = NULL; field->length = 0; /* this gets set by resizeField */ field->resizable = 1; /* set to 1 so we can use the resize code */ if (!nitf_Field_resizeField(field, length, error)) goto CATCH_ERROR; field->resizable = 0; /* set to 0 - the default value */ return field; CATCH_ERROR: if (field) nitf_Field_destruct(&field); return NULL; }
int main(int argc, char** argv) { try { nitf_Error e; // Foo<int>* foo = new Bar<int>(); // delete foo; nitf_Field* cField = nitf_Field_construct(100, NITF_BCS_N, &e); nitf::Field field(cField); { nitf::Field field2(cField); } std::cout << field.isValid() << std::endl; nitf_BandInfo* cBandInfo = nitf_BandInfo_construct(&e); assert(cBandInfo); nitf::BandInfo info(cBandInfo); std::cout << (int)info.getNumLUTs() << std::endl; std::cout << "HERE!!!!!!!!!!!!!!!!!!!!" << std::endl; nitf::SubWindow sub; nitf::SubWindow sub2 = sub; sub.setNumRows(5); nitf::PixelSkip p(1, 1); sub.setDownSampler(p); sub.setDownSampler(p); sub.setDownSampler(p); sub.setDownSampler(p); nitf::PixelSkip p2(1, 1); sub.setDownSampler(p2); sub.setDownSampler(p); nitf_SubWindow* subw = nitf_SubWindow_construct(&e); nitf::SubWindow sub3(subw); std::cout << sub.getNumRows() << " == " << sub2.getNumRows() << std::endl; nitf::List list; nitf::List list2 = list; { nitf::FileHeader header; nitf::FileHeader header2(header.clone()); //should be not equal std::cout << "Equal? " << (header == header2) << std::endl; nitf::FileHeader header3(header2); //these two should be equal std::cout << "Equal? " << (header3 == header2) << std::endl; } nitf::HashTable hash; nitf::Extensions extensions; { nitf::ImageSegment imageSeg; nitf::ImageSubheader imageSub; imageSeg.getSubheader().getImageId() = "Test Image"; std::cout << imageSeg.getSubheader().getImageId().toString() << std::endl; nitf::Field f = imageSeg.getSubheader().getImageId(); std::cout << f.toString() << std::endl; nitf::ImageSegment imageSeg2 = imageSeg.clone(); nitf::ImageSubheader imageSub2(imageSub.clone()); extensions = imageSub.getExtendedSection(); } nitf::TextSegment tSeg; nitf::TextSubheader tSub; nitf::GraphicSegment gSeg; nitf::GraphicSubheader gSub; nitf::DESegment dSeg; nitf::DESubheader dSub; nitf::LabelSegment rSeg; nitf::LabelSubheader rSub; nitf::TRE tre("JITCID"); //tre.print(); std::cout << "HERE!!!!!" << std::endl; nitf::Reader reader; nitf::Writer writer; //open a file sys::OS os; std::vector< std::string > files; for (int i = 1; i < argc; ++i) { if (!os.exists(argv[i])) std::cout << "Error -> File does not exist: " << argv[i] << std::endl; else files.push_back(argv[i]); } for (std::vector< std::string >::iterator it = files.begin(); it != files.end(); ++it) { nitf::IOHandle handle(*it); nitf::Reader rdr; nitf::Record rec = rdr.read(handle); std::cout << "CODEWORDS: " << rec.getHeader().getSecurityGroup().getCodewords().toString() << std::endl; rec.getHeader().getSecurityGroup().getCodewords() = "TEST"; std::cout << "CODEWORDS: " << rec.getHeader().getSecurityGroup().getCodewords().toString() << std::endl; nitf::FileSecurity security; rec.getHeader().setSecurityGroup(security); std::cout << "CODEWORDS: " << rec.getHeader().getSecurityGroup().getCodewords().toString() << std::endl; std::cout << "Num Images: " << rec.getImages().getSize() << std::endl; } nitf_SubWindow_destruct(&subw); nitf_Field_destruct(&cField); nitf_BandInfo_destruct(&cBandInfo); } catch(except::Exception& ex) { std::cerr << "ERROR: " << ex.getMessage() << std::endl; return 1; } return 0; }
NITFAPI(NITF_BOOL) nitf_TREUtils_fillData(nitf_TRE * tre, const nitf_TREDescription* descrip, nitf_Error * error) { nitf_TRECursor cursor; /* set the description so the cursor can use it */ ((nitf_TREPrivateData*)tre->priv)->description = (nitf_TREDescription*)descrip; /* loop over the description, and add blank fields for the * "normal" fields... any special case fields (loops, conditions) * won't be added here */ cursor = nitf_TRECursor_begin(tre); while (!nitf_TRECursor_isDone(&cursor)) { if (nitf_TRECursor_iterate(&cursor, error)) { nitf_Pair* pair = nitf_HashTable_find( ((nitf_TREPrivateData*)tre->priv)->hash, cursor.tag_str); if (!pair || !pair->data) { nitf_Field* field = NULL; int fieldLength = cursor.length; /* If it is a GOBBLE length, there isn't really a standard * on how long it can be... therefore we'll just throw in * a field of size 1, just to have something... */ if (fieldLength == NITF_TRE_GOBBLE) { fieldLength = 1; } field = nitf_Field_construct(fieldLength, cursor.desc_ptr->data_type, error); /* set the field to be resizable later on */ if (cursor.length == NITF_TRE_GOBBLE) field->resizable = 1; /* special case if BINARY... must set Raw Data */ if (cursor.desc_ptr->data_type == NITF_BINARY) { char* tempBuf = (char *) NITF_MALLOC(fieldLength); if (!tempBuf) { nitf_Field_destruct(&field); nitf_Error_init(error, NITF_STRERROR(NITF_ERRNO), NITF_CTXT, NITF_ERR_MEMORY); goto CATCH_ERROR; } memset(tempBuf, 0, fieldLength); nitf_Field_setRawData(field, (NITF_DATA *) tempBuf, fieldLength, error); } else if (cursor.desc_ptr->data_type == NITF_BCS_N) { /* this will get zero/blank filled by the function */ nitf_Field_setString(field, "0", error); } else { /* this will get zero/blank filled by the function */ nitf_Field_setString(field, " ", error); } /* add to hash if there wasn't an entry yet */ if (!pair) { nitf_HashTable_insert( ((nitf_TREPrivateData*)tre->priv)->hash, cursor.tag_str, field, error); } /* otherwise, just set the data pointer */ else { pair->data = (NITF_DATA *) field; } } } } nitf_TRECursor_cleanup(&cursor); /* no problems */ /* return tre->descrip; */ return NITF_SUCCESS; CATCH_ERROR: return NITF_FAILURE; }