diff options
Diffstat (limited to 'Skin++/src/Clcm.cxx')
| -rwxr-xr-x | Skin++/src/Clcm.cxx | 1308 |
1 files changed, 1308 insertions, 0 deletions
diff --git a/Skin++/src/Clcm.cxx b/Skin++/src/Clcm.cxx new file mode 100755 index 0000000..4ea27ca --- /dev/null +++ b/Skin++/src/Clcm.cxx @@ -0,0 +1,1308 @@ + +/*****************************************/ +/* C++ LCM OBJECT WRAPPER */ +/* AUTHOR: A. HEBERT ; 2024/08/04 */ +/*****************************************/ + +/* +Copyright (C) 2010 Ecole Polytechnique de Montreal + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. +*/ + +#include "Clcm.hxx" + +using namespace std; +using namespace ganlib; +static ostringstream hsmg; + +/* abort condition setting */ +void xabort_c(char *msg){ + cout << "Clcm xabort called: " << string(msg) << endl; + throw LCMexception(msg); +} + +ganlib::Clcm::Clcm(const string stype, const string myName, const string myPath) { + cout << "New Clcm object called '" << myName << "'" << endl; + this->root = this; + this->global_list = new vector<AnyPtr>; + this->isroot = true; + this->version = 4; + bool l_import = false; + bool l_exists = false; + int_32 imode=0; + if (stype == "LCM") { + this->objtype = 1; + } else if (stype == "XSM") { + DIR *dp; + struct dirent *dirp; + this->objtype = 2; + vector<string> names = vector<string>(); + if((dp = opendir(myPath.c_str())) == NULL) { + hsmg << "no XSM file found (missing directory name: '" << myPath << ")'" << endl; + throw LCMexception(hsmg.str()); + } + while ((dirp = readdir(dp)) != NULL) { + names.push_back(string(dirp->d_name)); + } + closedir(dp); + for (size_t i=0; i<names.size(); i++) { + if (names[i] == myName) l_exists = true; + } + } else if (stype == "BINARY") { + this->objtype = 3; + } else if (stype == "ASCII") { + this->objtype = 4; + } else if (stype == "DA") { + this->objtype = 5; + } else if (stype == "LCM_IMP_BINARY") { + imode = 1; + this->objtype = 1; + l_import = true; + } else if (stype == "XSM_IMP_BINARY") { + imode = 1; + this->objtype = 2; + l_import = true; + } else if (stype == "LCM_IMP_ASCII") { + imode = 2; + this->objtype = 1; + l_import = true; + } else if (stype == "XSM_IMP_ASCII") { + imode = 2; + this->objtype = 2; + l_import = true; + } else if (stype == "LCM_IMP_ASCII_V3") { + imode = 2; + this->objtype = 1; + this->version = 3; + l_import = true; + } else { + throw LCMexception("invalid type: '" + stype + "'"); + } + this->access = 0; + this->name = myName; + this->path = myPath; + this->addr = NULL; + this->lrda = 128; + try { + if (l_exists) { + this->addr = NULL; + cout << "XSM file " << path << myName << " already exists\n"; + this->open("READ-ONLY"); + this->access = 2; + } else { + this->open("NEW"); + this->access = 1; + } + } catch(...) { + throw LCMexception("Exception catched by new(1)"); + } + if (this->objtype <= 2) { + this->nammy = "/"; + this->empty = true; + this->ilong = -1; + } + if (l_import) { + this->empty = false; + this->untoutched = false; + try { + DIR *dp; + struct dirent *dirp; + vector<string> names = vector<string>(); + if((dp = opendir(myPath.c_str())) == NULL) { + hsmg << "no ASCII file found (missing directory name: '" << myPath << ")'" << endl; + throw LCMexception(hsmg.str()); + } + while ((dirp = readdir(dp)) != NULL) { + names.push_back(string(dirp->d_name)); + } + closedir(dp); + for (size_t i=0; i<names.size(); i++) { + string::size_type loc = names[i].find("_"); + if( loc != string::npos ) { + string fileName = names[i].substr(loc, string::npos); + if (fileName == "_"+this->name) { + FILE *file; + file = fopen((myPath+names[i]).c_str(), "r"); + if (this->version == 4) { + lcmexp_c(&(this->addr), 0, file, imode, 2); + } + else { + lcmexpv3_c(&(this->addr), 0, file, imode, 2); + } + fclose(file); + return; + } + } + } + // Modified R. Chambon 09/2011 + for (size_t i=0; i<names.size(); i++) { + if (myName.compare(names[i]) == 0) { + FILE *file; + file = fopen((myPath+names[i]).c_str(), "r"); + if (this->version == 4) { + lcmexp_c(&(this->addr), 0, file, imode, 2); + } + else { + lcmexpv3_c(&(this->addr), 0, file, imode, 2); + } + fclose(file); + return; + } + } + // + hsmg << "File '" << "_" << this->name << "' not found in '" << myPath <<"'"; + throw LCMexception(hsmg.str()); + } catch(...) { + throw LCMexception("Exception catched by new(2)"); + } + } +} + +ganlib::Clcm::Clcm(lcm *daughter, Clcm *root, const int_32 type, const string name, const int_32 ilong, const string key) { + this->global_list = root->global_list; + this->root = root; + this->addr = daughter; + this->access = 1; + this->name = name; + this->path = "./"; + this->nammy = key; + this->empty = true; + this->ilong = ilong; + this->objtype = type; + this->untoutched = false; + this->isroot = false; + this->version = root->version; +} + +ganlib::Clcm::Clcm(lcm *myLcm, const int_32 type, const int_32 access, const string OSname) { + this->root = this; + this->global_list = new vector<AnyPtr>; + this->isroot = false; + this->version = 4; + this->addr = myLcm; + this->access = access; + this->ilong = -1; + this->objtype = type-2; + this->empty = false; + this->name = OSname; + this->nammy = "/"; + this->path = ""; + this->untoutched = true; +} + +ganlib::Clcm::Clcm(const string stype, ClcmPtr myClcm) { + if (myClcm->objtype > 2) throw LCMexception("copy constructor not available for file objects"); + if (stype == "LCM") { + this->objtype = 1; + } else if (stype == "XSM") { + this->objtype = 2; + } + bool lopen = true; + if (myClcm->access == 0) { + lopen = false; + myClcm->open("READ-ONLY"); + } + this->version = root->version; + this->name = myClcm->name + ".bis"; + cout << "New Clcm object (clone) called '" << this->name << "'" << endl; + this->open("NEW"); + this->access = 1; + lcm *myLcm = myClcm->addr; + lcmequ_c(&myLcm, &(this->addr)); + this->root = this; + this->global_list = new vector<AnyPtr>; + this->isroot = true; + this->path = myClcm->path; + this->lrda = myClcm->lrda; + if (!lopen) { + myClcm->close("KEEP"); + this->close("KEEP"); + } +} + +ganlib::Clcm::~Clcm() { + if (this->isroot) { + cout << "Clcm root destructor called. LCM object=" << this->name << endl; + if ((this->addr != NULL) & (this->access == 1)) { + cout << "Destroy object " << this->name << endl; + this->close("DESTROY"); + } else if ((this->addr != NULL) & (this->access == 2)) { + cout << "Keep object " << this->name << endl; + this->close("KEEP"); + } + if (this->global_list != NULL) delete this->global_list; + } +} + +ostream & ganlib::operator<<(ostream &s, ClcmPtr myClcm) { + if (myClcm->objtype > 2) throw LCMexception("operator<< not available for file objects"); + FILE *file = fopen("_dummy.txt", "w"); + if (file == NULL) { + throw LCMexception("fopen failure in operator<<. file=_dummy.txt"); + } + lcmexp_c(&(myClcm->addr), 0, file, 2, 1); + fclose(file); + ifstream ifs ( "_dummy.txt" , ifstream::in ); + while (ifs.good()) s << (char) ifs.get(); + ifs.close(); + if( remove("_dummy.txt") != 0 ) { + throw LCMexception("Error deleting file after <<: _dummy.txt"); + } + return s; +} + +void ganlib::Clcm::expor(const string stype) { + this->expor(stype, "_"+this->name); +} + +void ganlib::Clcm::expor(const string stype, const string new_name) { + if (this->objtype > 2) throw LCMexception("expor not available for file objects"); + int_32 imode; + if (stype == "BINARY") { + imode = 1; + } else if (stype == "ASCII") { + imode = 2; + } else { + throw LCMexception("invalid type: '" + stype + "'"); + } + size_t found=new_name.find("_"); + if (found == string::npos) { + throw LCMexception("Export file name ("+new_name+") must contains _"); + } + FILE *file = fopen(new_name.c_str(), "w"); + if (file == NULL) { + throw LCMexception("fopen failure in expor(). file="+new_name); + } + lcmexp_c(&(this->addr), 0, file, imode, 1); + fclose(file); +} + +void ganlib::Clcm::except() { + throw LCMexception("Programmer-triggered exception"); +} + +string ganlib::Clcm::getName() throw() { + return this->name; +} + +string ganlib::Clcm::getPath() throw() { + return this->path; +} + +int_32 ganlib::Clcm::getType() throw() { + return this->objtype; +} + +int_32 ganlib::Clcm::getLength() { + char namlcm[73], nammy[13]; + int_32 empty, ilong, lcml, access; + if (this->objtype > 2) throw LCMexception("getLength not available for file objects"); + lcminf_c(&(this->addr), namlcm, nammy, &empty, &ilong, &lcml, &access); + return ilong; +} + +string ganlib::Clcm::getDirectory() { + char namlcm[73], nammy[13]; + int_32 empty, ilong, lcml, access; + if (this->objtype > 2) throw LCMexception("getDirectory not available for file objects"); + lcminf_c(&(this->addr), namlcm, nammy, &empty, &ilong, &lcml, &access); + return nammy; +} + +int_32 ganlib::Clcm::getAccess() { + char namlcm[73], nammy[13]; + int_32 empty, ilong, lcml; + if (this->objtype <= 2) { + lcminf_c(&(this->addr), namlcm, nammy, &empty, &ilong, &lcml, &(this->access)); + } + return this->access; +} + +int_32 ganlib::Clcm::getLrda() throw() { + return this->lrda; +} + +int_32 ganlib::Clcm::getVersion() throw() { + return this->version; +} + +bool ganlib::Clcm::isEmpty() { + char namlcm[73], nammy[13]; + int_32 empty, ilong, lcml, access; + if (this->objtype > 2) throw LCMexception("isEmpty not available for file objects"); + lcminf_c(&(this->addr), namlcm, nammy, &empty, &ilong, &lcml, &access); + return empty; +} + +bool ganlib::Clcm::isNew() throw() { + return this->untoutched; +} + +void ganlib::Clcm::open(const string saccess) { + if (this->access != 0) { + throw LCMexception("the object " + this->name + " is already open"); + } + if (saccess == "NEW") { + this->untoutched = true; + } else if (saccess == "READ/WRITE") { + if ((this->addr == NULL)&(this->objtype == 1)) { + throw LCMexception("the object " + this->name + " is destroyed(1)"); + } + this->access = 1; + this->untoutched = false; + } else if (saccess == "READ-ONLY") { + if ((this->addr == NULL)&(this->objtype == 1)) { + throw LCMexception("the object " + this->name + " is destroyed(2)"); + } + this->access = 2; + this->untoutched = false; + } else { + throw LCMexception("invalid access: '" + saccess + "'"); + } + if (this->objtype == 1) { + try { + lcmop_c(&(this->addr), (char *)(this->name).c_str(), this->access, this->objtype, 99); + } catch(...) { + throw LCMexception("Exception catched by open (1)"); + } + } else if (this->objtype == 2) { + try { + lcmop_c(&(this->addr), (char *)(this->path+this->name).c_str(), this->access, this->objtype, 0); + } catch(...) { + throw LCMexception("Exception catched by open (1)"); + } + } else if (this->objtype <= 5) { + this->addr = NULL; + bool exs = false; + DIR *dp; + struct dirent *dirp; + vector<string> names = vector<string>(); + if((dp = opendir(this->path.c_str())) == NULL) { + hsmg << "no file found (missing directory name: '" << this->path << ")'" << endl; + throw LCMexception(hsmg.str()); + } + while ((dirp = readdir(dp)) != NULL) { + names.push_back(string(dirp->d_name)); + } + closedir(dp); + for (size_t i=0; i<names.size(); i++) { + if (names[i] == this->name) exs = true; + } + if (this->access == 0) { + if (exs) { + hsmg << "New file " << this->path << this->name << " exists";; + throw LCMexception(hsmg.str()); + } + } else if (this->access == 1) { + if (!exs) { + hsmg << "Old file " << this->path << this->name << " does not exist(1)";; + throw LCMexception(hsmg.str()); + } + } else if (this->access == 2) { + if (!exs) { + hsmg << "Old file " << this->path << this->name << " does not exist(2)";; + throw LCMexception(hsmg.str()); + } + } + } else { + hsmg << "invalid type in open (" << this->objtype << ")"; + throw LCMexception(hsmg.str()); + } +} + +void ganlib::Clcm::close(const string saccess) { + int iact; + if (saccess == "KEEP") { + iact = 1; + } else if (saccess == "DESTROY") { + iact = 2; + } else if (saccess == "ERASE") { + iact = 3; + } else { + throw LCMexception("invalid condition: '" + saccess + "'"); + } + if (this->access != 0) { + if (this->objtype <= 2) { + try { + lcmcl_c(&(this->addr), iact); + } catch(...) { + throw LCMexception("Exception catched by close(1)"); + } + } else if (this->objtype <= 5) { + if (iact >= 2) { + try { + this->aFile.close(); + if( remove((this->path+this->name).c_str()) != 0 ) { + throw LCMexception("Error deleting file: " + this->path + this->name); + } + cout << "File deleted:" << this->path << this->name << endl; + } catch(...) { + throw LCMexception("Exception catched by close(2)"); + } + } + } + } else { + throw LCMexception("the object " + this->name + " is already closed"); + } + if (iact == 2) { + this->addr = NULL; + } + this->access = 0; +} + +int_32 ganlib::Clcm::length(const std::string key) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("length not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (itylcm == 3) mylength=4*mylength; + return mylength; +} + +int_32 ganlib::Clcm::length(const int_32 iset) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("length not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (itylcm == 3) mylength=4*mylength; + return mylength; +} + +int_32 ganlib::Clcm::type(const std::string key) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("type not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (itylcm == 99) { + hsmg << "length: no block named '" << key << "'"; + throw LCMexception(hsmg.str()); + } + return itylcm; +} + +int_32 ganlib::Clcm::type(const int_32 iset) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("type not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (itylcm == 99) { + hsmg << "length: no block at position " << iset << "."; + throw LCMexception(hsmg.str()); + } + return itylcm; +} + +void ganlib::Clcm::lib() { + if (this->objtype > 2) throw LCMexception("lib not available for file objects"); + lcmlib_c(&(this->addr)); +} + +void ganlib::Clcm::val() { + if (this->objtype > 2) throw LCMexception("val not available for file objects"); + lcmval_c(&(this->addr), " "); +} + +//---------------------------------------------------------------------- +//-- set -- +//---------------------------------------------------------------------- + +ClcmPtr ganlib::Clcm::setDictionary(const std::string key) { + if (this->objtype > 2) throw LCMexception("setDictionary not available for file objects"); + lcm *daughter = lcmdid_c(&(this->addr), (char *)key.c_str()); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, -1, key)); +} + +ClcmPtr ganlib::Clcm::setDictionary(const int_32 iset) { + if (this->objtype > 2) throw LCMexception("setDictionary not available for file objects"); + lcm *daughter = lcmdil_c(&(this->addr), iset); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, -1, " ")); +} + +ClcmPtr ganlib::Clcm::setList(const std::string key, const int_32 ilong) { + if (this->objtype > 2) throw LCMexception("setList not available for file objects"); + lcm *daughter = lcmlid_c(&(this->addr), (char *)key.c_str(), ilong); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, 0, key)); +} + +ClcmPtr ganlib::Clcm::setList(const int_32 iset, const int_32 ilong) { + if (this->objtype > 2) throw LCMexception("setList not available for file objects"); + lcm *daughter = lcmlil_c(&(this->addr), iset, ilong); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, 0, " ")); +} + +//---------------------------------------------------------------------- +//-- get -- +//---------------------------------------------------------------------- + +ClcmPtr ganlib::Clcm::getClcm(const std::string key) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getClcm not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getClcm(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } + if (itylcm == 0) { + lcm *daughter = lcmgid_c(&(this->addr), (char *)key.c_str()); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, -1, key)); + } else if (itylcm == 10) { + lcm *daughter = lcmgid_c(&(this->addr), (char *)key.c_str()); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, 0, key)); + } else { + hsmg << "getClcm(" << key << ") expecting a Clcm object(1)"; + throw LCMexception(hsmg.str()); + } +} + +ClcmPtr ganlib::Clcm::getClcm(const int_32 iset) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getClcm not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getClcm(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } + if (itylcm == 0) { + lcm *daughter = lcmgil_c(&(this->addr), iset); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, -1, " ")); + } else if (itylcm == 10) { + lcm *daughter = lcmgil_c(&(this->addr), iset); + return ClcmPtr(new Clcm(daughter, this->root, this->objtype, this->name, 0, " ")); + } else { + hsmg << "getClcm(" << iset << ") expecting a Clcm object(2)"; + throw LCMexception(hsmg.str()); + } +} + +/// @cond DEV +// Use this destructor to avoid deleting LCM array pointed by the shared_array object +template<typename T> +struct my_deleter +{ + void operator()(T* p) { } +}; +/// @endcond + +IntPtrConst ganlib::Clcm::getInt(const std::string key) { + int_32 mylength, itylcm; + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getInt(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 1) { + hsmg << "getInt(" << key << ") expecting an integer array(1)"; + throw LCMexception(hsmg.str()); + } + if (this->objtype == 1) { + // Use a reference without copy (pinning). + int_32 *array; + lcmgpd_c(&(this->addr), (char *)key.c_str(), &array); + IntPtrConst iarray(array, my_deleter<const int_32>()); + return iarray; + } else if (this->objtype == 2) { + // Use a reference with copy. + IntPtrConst iarray(new int_32[mylength]); + lcmget_c(&(this->addr), (char *)key.c_str(), (int_32 *)iarray.get()); + return iarray; + } else { + throw LCMexception("getInt not available for file objects"); + } +} + +IntPtrConst ganlib::Clcm::getInt(const int_32 iset) { + int_32 mylength, itylcm; + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getInt(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 1) { + hsmg << "getInt(" << iset << ") expecting an integer array(2)"; + throw LCMexception(hsmg.str()); + } + if (this->objtype == 1) { + // Use a reference without copy (pinning). + int_32 *array; + lcmgpl_c(&(this->addr), iset, &array); + IntPtrConst iarray(array, my_deleter<const int_32>()); + return iarray; + } else if (this->objtype == 2) { + // Use a reference with copy. + IntPtrConst iarray(new int_32[mylength]); + lcmgdl_c(&(this->addr), iset, (int_32 *)iarray.get()); + return iarray; + } else { + throw LCMexception("getInt not available for file objects"); + } +} + +FloatPtrConst ganlib::Clcm::getFloat(const std::string key) { + int_32 mylength, itylcm; + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getFloat(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 2) { + hsmg << "getFloat(" << key << ") expecting a single precision real array(1)"; + throw LCMexception(hsmg.str()); + } + if (this->objtype == 1) { + // Use a reference without copy (pinning). + float_32 *array; + lcmgpd_c(&(this->addr), (char *)key.c_str(), (int_32 **)&array); + FloatPtrConst iarray(array, my_deleter<const float_32>()); + return iarray; + } else if (this->objtype == 2) { + // Use a reference with copy. + FloatPtrConst iarray(new float_32[mylength]); + lcmget_c(&(this->addr), (char *)key.c_str(), (int_32 *)iarray.get()); + return iarray; + } else { + throw LCMexception("getFloat not available for file objects"); + } +} + +FloatPtrConst ganlib::Clcm::getFloat(const int_32 iset) { + int_32 mylength, itylcm; + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getFloat(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 2) { + hsmg << "getFloat(" << iset << ") expecting a single precision real array(2)"; + throw LCMexception(hsmg.str()); + } + if (this->objtype == 1) { + // Use a reference without copy (pinning). + float_32 *array; + lcmgpl_c(&(this->addr), iset, (int_32 **)&array); + FloatPtrConst iarray(array, my_deleter<const float_32>()); + return iarray; + } else if (this->objtype == 2) { + // Use a reference with copy. + FloatPtrConst iarray(new float_32[mylength]); + lcmgdl_c(&(this->addr), iset, (int_32 *)iarray.get()); + return iarray; + } else { + throw LCMexception("getFloat not available for file objects"); + } +} + +StringPtrConst ganlib::Clcm::getString(const std::string key) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getString not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getString(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 3) { + hsmg << "getString(" << key << ") expecting a character array(1)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpd_c(&(this->addr), (char *)key.c_str(), &iarray); + return StringPtrConst(new string((char*)iarray, 4*mylength)); +} + +StringPtrConst ganlib::Clcm::getString(const int_32 iset) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getString not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getString(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 3) { + hsmg << "getString(" << iset << ") expecting a character array(2)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpl_c(&(this->addr), iset, &iarray); + return StringPtrConst(new string((char*)iarray, 4*mylength)); +} + +StringVecPtr ganlib::Clcm::getVecString(const std::string key, const int_32 size) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getVecString not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getVecString(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 3) { + hsmg << "getVecString(" << key << ") expecting a character array(1)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpd_c(&(this->addr), (char *)key.c_str(), &iarray); + StringVecPtr ivecPtr = StringVecPtr(new vector<string>); + for (int i=0; i<size; i++) { + int_32 nbchar = ( mylength*4 + size - 1) / size; + int_32 istart = nbchar*i; + if (i == size-1) nbchar = mylength*4 - nbchar*i; + if (nbchar != 0) { + string myString = string((char *)iarray, istart, nbchar); + ivecPtr->push_back(myString.substr(0, myString.find_last_not_of(" ")+1)); + } + } + return ivecPtr; +} + +StringVecPtr ganlib::Clcm::getVecString(const int_32 iset, const int_32 size) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getVecString not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getVecString(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 3) { + hsmg << "getVecString(" << iset << ") expecting a character array(2)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpl_c(&(this->addr), iset, &iarray); + StringVecPtr ivecPtr = StringVecPtr(new vector<string>); + for (int i=0; i<size; i++) { + int_32 nbchar = ( mylength*4 + size - 1) / size; + int_32 istart = nbchar*i; + if (i == size-1) nbchar = mylength*4 - nbchar*i; + if (nbchar != 0) { + string myString = string((char *)iarray, istart, nbchar); + ivecPtr->push_back(myString.substr(0, myString.find_last_not_of(" ") + 1)); + } + } + return ivecPtr; +} + +DoublePtrConst ganlib::Clcm::getDouble(const std::string key) { + int_32 mylength, itylcm; + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getDouble(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 4) { + hsmg << "getDouble(" << key << ") expecting a double precision real array(1)"; + throw LCMexception(hsmg.str()); + } + if (this->objtype == 1) { + // Use a reference without copy (pinning). + double_64 *array; + lcmgpd_c(&(this->addr), (char *)key.c_str(), (int_32 **)&array); + DoublePtrConst iarray(array, my_deleter<const double_64>()); + return iarray; + } else if (this->objtype == 2) { + // Use a reference with copy. + DoublePtrConst iarray(new double_64[mylength]); + lcmget_c(&(this->addr), (char *)key.c_str(), (int_32 *)iarray.get()); + return iarray; + } else { + throw LCMexception("getDouble not available for file objects"); + } +} + +DoublePtrConst ganlib::Clcm::getDouble(const int_32 iset) { + int_32 mylength, itylcm; + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getDouble(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 4) { + hsmg << "getDouble(" << iset << ") expecting a double precision real array(2)"; + throw LCMexception(hsmg.str()); + } + if (this->objtype == 1) { + // Use a reference without copy (pinning). + double_64 *array; + lcmgpl_c(&(this->addr), iset, (int_32 **)&array); + DoublePtrConst iarray(array, my_deleter<const double_64>()); + return iarray; + } else if (this->objtype == 2) { + // Use a reference with copy. + DoublePtrConst iarray(new double_64[mylength]); + lcmgdl_c(&(this->addr), iset, (int_32 *)iarray.get()); + return iarray; + } else { + throw LCMexception("getDouble not available for file objects"); + } +} + +BoolPtrConst ganlib::Clcm::getBool(const std::string key) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getBool not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getBool(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 5) { + hsmg << "getBool(" << key << ") expecting a boolean array(1)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpd_c(&(this->addr), (char *)key.c_str(), &iarray); + BoolPtrConst ibool(new bool[mylength]); + bool *myBool = (bool *)ibool.get(); + for (int i=0; i<mylength; i++) myBool[i] = (iarray[i] == 1); + return ibool; +} + +BoolPtrConst ganlib::Clcm::getBool(const int_32 iset) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getBool not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getBool(" << iset << ") entry is missing(2)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 5) { + hsmg << "getBool(" << iset << ") expecting a boolean array(2)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpl_c(&(this->addr), iset, &iarray); + BoolPtrConst ibool(new bool[mylength]); + bool *myBool = (bool *)ibool.get(); + for (int i=0; i<mylength; i++) myBool[i] = (iarray[i] == 1); + return ibool; +} + +ComplexPtrConst ganlib::Clcm::getComplex(const std::string key) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getComplex not available for file objects"); + lcmlen_c(&(this->addr), (char *)key.c_str() ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getComplex(" << key << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 6) { + hsmg << "getComplex(" << key << ") expecting a Complex array(1)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpd_c(&(this->addr), (char *)key.c_str(), &iarray); + complex<float_32> *icomplex = new complex<float_32>[mylength]; + for (int i=0; i<mylength; i++) { + icomplex[i] = complex<float_32>((float_32)iarray[2*i],(float_32)iarray[1+2*i]); + } + return ComplexPtrConst(icomplex); +} + +ComplexPtrConst ganlib::Clcm::getComplex(const int_32 iset) { + int_32 mylength, itylcm; + if (this->objtype > 2) throw LCMexception("getComplex not available for file objects"); + lcmlel_c(&(this->addr), iset ,&mylength, &itylcm); + if (mylength == 0) { + hsmg << "getComplex(" << iset << ") entry is missing(1)"; + throw LCMexception(hsmg.str()); + } else if (itylcm != 6) { + hsmg << "getComplex(" << iset << ") expecting a Complex array(2)"; + throw LCMexception(hsmg.str()); + } + // Use a reference with copy. + int_32 *iarray; + lcmgpl_c(&(this->addr), iset, &iarray); + complex<float_32> *icomplex = new complex<float_32>[mylength]; + for (int i=0; i<mylength; i++) { + icomplex[i] = complex<float_32>((float_32)iarray[2*i],(float_32)iarray[1+2*i]); + } + return ComplexPtrConst(icomplex); +} + +//---------------------------------------------------------------------- +//-- keys -- +//---------------------------------------------------------------------- + +StringVecPtr ganlib::Clcm::keys() { + if (this->objtype > 2) throw LCMexception("keys not available for file objects"); + if (this->getLength() != -1) throw LCMexception("keys only available for dictionaries"); + StringVecPtr ivecPtr = StringVecPtr(new vector<string>); + char first[13], key[13]; + strcpy(first, " "); + lcmnxt_c(&(this->addr), first); + strcpy(key, first); + while (true) { + lcmnxt_c(&(this->addr), key); + ivecPtr->push_back(string(key)); + if (strcmp(key, first) == 0) break; + } + return ivecPtr; +} + +//---------------------------------------------------------------------- +//-- put -- +//---------------------------------------------------------------------- + +void ganlib::Clcm::put(const std::string key, IntPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + int_32 *myArrayPointer = (int_32 *)myArray.get(); + if ((this->objtype == 1) && (this->global_list != NULL)) { + // Use a reference without copy (pinning) for memory-resident lcm objects. + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 1, myArrayPointer); + refpush(&(this->addr), myArrayPointer); + (this->global_list)->push_back(myArray); + } else if (this->objtype == 1) { + // Use a reference with copy for memory-resident lcm objects (the lcm object is + // coming from outside C++). + int_32 *iarray = setara_c(myLength); + for (int i=0; i<myLength; i++) iarray[i] = myArrayPointer[i]; + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 1, iarray); + } else if (this->objtype == 2) { + // Use a reference with copy for xsm file objects. + xsm *ipxsm = (xsm *)(this->addr); + xsmput_c(&ipxsm, (char *)key.c_str(), myLength, 1, myArrayPointer); + } + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, IntPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + int_32 *myArrayPointer = (int_32 *)myArray.get(); + if ((this->objtype == 1) && (this->global_list != NULL)) { + // Use a reference without copy (pinning) for memory-resident lcm objects. + lcmppl_c(&(this->addr), iset, myLength, 1, myArrayPointer); + refpush(&(this->addr), myArrayPointer); + (this->global_list)->push_back(myArray); + } else if (this->objtype == 1) { + // Use a reference with copy for memory-resident lcm objects (the lcm object is + // coming from outside C++). + int_32 *iarray = setara_c(myLength); + for (int i=0; i<myLength; i++) iarray[i] = myArrayPointer[i]; + lcmppl_c(&(this->addr), iset, myLength, 1, iarray); + } else if (this->objtype == 2) { + // Use a reference with copy for xsm file objects. + xsm *ipxsm = (xsm *)(this->addr) + iset; + xsmput_c(&ipxsm, " ", myLength, 1, myArrayPointer); + } + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, FloatPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + float_32 *myArrayPointer = (float_32 *)myArray.get(); + if ((this->objtype == 1) && (this->global_list != NULL)) { + // Use a reference without copy (pinning) for memory-resident lcm objects. + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 2, (int_32 *)myArrayPointer); + refpush(&(this->addr), (int_32 *)myArrayPointer); + (this->global_list)->push_back(myArray); + } else if (this->objtype == 1) { + // Use a reference with copy for memory-resident lcm objects (the lcm object is + // coming from outside C++). + int_32 *iarray = setara_c(myLength); + for (int i=0; i<myLength; i++) iarray[i] = (int_32)myArrayPointer[i]; + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 2, iarray); + } else if (this->objtype == 2) { + // Use a reference with copy for xsm file objects. + xsm *ipxsm = (xsm *)(this->addr); + xsmput_c(&ipxsm, (char *)key.c_str(), myLength, 2, (int_32 *)myArrayPointer); + } + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, FloatPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + float_32 *myArrayPointer = (float_32 *)myArray.get(); + if ((this->objtype == 1) && (this->global_list != NULL)) { + // Use a reference without copy (pinning) for memory-resident lcm objects. + lcmppl_c(&(this->addr), iset, myLength, 2, (int_32 *)myArrayPointer); + refpush(&(this->addr), (int_32 *)myArrayPointer); + (this->global_list)->push_back(myArray); + } else if (this->objtype == 1) { + // Use a reference with copy for memory-resident lcm objects (the lcm object is + // coming from outside C++). + int_32 *iarray = setara_c(myLength); + for (int i=0; i<myLength; i++) iarray[i] = (int_32)myArrayPointer[i]; + lcmppl_c(&(this->addr), iset, myLength, 2, iarray); + } else if (this->objtype == 2) { + // Use a reference with copy for xsm file objects. + xsm *ipxsm = (xsm *)(this->addr) + iset; + xsmput_c(&ipxsm, " ", myLength, 2, (int_32 *)myArrayPointer); + } + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, StringPtr myArray) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if ((myArray.get())->length() <= 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + int_32 ilen = ((myArray.get())->length()+3)/4; + int_32 *iarray = (int_32 *)setara_c(ilen); + for (int i=0; i<ilen; i++) memcpy((char *)&iarray[i], " ", 4); + string myString = *myArray.get(); + strncpy((char *)iarray, myString.c_str(), myString.length()); + lcmppd_c(&(this->addr), (char *)key.c_str(), ilen, 3, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, StringPtr myArray) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if ((myArray.get())->length() <= 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + int_32 ilen = ((myArray.get())->length()+3)/4; + int_32 *iarray = (int_32 *)setara_c(ilen); + for (int i=0; i<ilen; i++) memcpy((char *)&iarray[i], " ", 4); + string myString = *myArray.get(); + strncpy((char *)iarray, myString.c_str(), myString.length()); + lcmppl_c(&(this->addr), iset, ilen, 3, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, StringVecPtr myArray) { + const vector<string> *ivec = (vector<string>*)myArray.get(); + const int_32 mySize = ivec->size(); + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if (mySize <= 0) { + hsmg << "put(" << key << ") has zero size(1)"; + throw LCMexception(hsmg.str()); + } + int_32 maxLength = 0; + for (int i=0; i<mySize; i++) { + maxLength = max(maxLength, (int_32)(*ivec)[i].length()); + } + if (maxLength == 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + maxLength = (maxLength+3)/4; + int_32 *iarray = (int_32 *)setara_c(maxLength*mySize); + for (int i=0; i<maxLength*mySize; i++) memcpy((char *)&iarray[i], " ", 4); + for (int i=0; i<mySize; i++) { + string myString = (*ivec)[i]; + strncpy((char *)&iarray[maxLength*i], myString.c_str(), myString.length()); + } + lcmppd_c(&(this->addr), (char *)key.c_str(), maxLength*mySize, 3, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, StringVecPtr myArray) { + const vector<string> *ivec = (vector<string>*)myArray.get(); + const int_32 mySize = ivec->size(); + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if (mySize <= 0) { + hsmg << "put(" << iset << ") has zero size(2)"; + throw LCMexception(hsmg.str()); + } + int_32 maxLength = 0; + for (int i=0; i<mySize; i++) { + maxLength = max(maxLength, (int_32)(*ivec)[i].length()); + } + if (maxLength == 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + maxLength = (maxLength+3)/4; + int_32 *iarray = (int_32 *)setara_c(maxLength*mySize); + for (int i=0; i<maxLength*mySize; i++) memcpy((char *)(&iarray[i]), " ", 4); + for (int i=0; i<mySize; i++) { + string myString = (*ivec)[i]; + strncpy((char *)(&iarray[maxLength*i]), myString.c_str(), myString.length()); + } + lcmppl_c(&(this->addr), iset, maxLength*mySize, 3, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, DoublePtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + double_64 *myArrayPointer = (double_64 *)myArray.get(); + if ((this->objtype == 1) && (this->global_list != NULL)) { + // Use a reference without copy (pinning) for memory-resident lcm objects. + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 4, (int_32 *)myArrayPointer); + refpush(&(this->addr), (int_32 *)myArrayPointer); + (this->global_list)->push_back(myArray); + } else if (this->objtype == 1) { + // Use a reference with copy for memory-resident lcm objects (the lcm object is + // coming from outside C++). + int_32 *iarray = setara_c(2*myLength); + for (int i=0; i<2*myLength; i++) iarray[i] = ((int_32 *)myArrayPointer)[i]; + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 4, iarray); + } else if (this->objtype == 2) { + // Use a reference with copy for xsm file objects. + xsm *ipxsm = (xsm *)(this->addr); + xsmput_c(&ipxsm, (char *)key.c_str(), myLength, 4, (int_32 *)myArrayPointer); + } + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, DoublePtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + double_64 *myArrayPointer = (double_64 *)myArray.get(); + if ((this->objtype == 1) && (this->global_list != NULL)) { + // Use a reference without copy (pinning) for memory-resident lcm objects. + lcmppl_c(&(this->addr), iset, myLength, 4, (int_32 *)myArrayPointer); + refpush(&(this->addr), (int_32 *)myArrayPointer); + (this->global_list)->push_back(myArray); + } else if (this->objtype == 1) { + // Use a reference with copy for memory-resident lcm objects (the lcm object is + // coming from outside C++). + int_32 *iarray = setara_c(2*myLength); + for (int i=0; i<2*myLength; i++) iarray[i] = ((int_32 *)myArrayPointer)[i]; + lcmppl_c(&(this->addr), iset, myLength, 4, iarray); + } else if (this->objtype == 2) { + // Use a reference with copy for xsm file objects. + xsm *ipxsm = (xsm *)(this->addr) + iset; + xsmput_c(&ipxsm, " ", myLength, 4, (int_32 *)myArrayPointer); + } + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, BoolPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + bool *myArrayPointer = (bool *)myArray.get(); + // Use a reference with copy. + int_32 *iarray = setara_c(myLength); + for (int i=0; i<myLength; i++) { + myArrayPointer[i] ? iarray[2*i] = 1 : iarray[2*i] = 0; + } + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 5, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, BoolPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + bool *myArrayPointer = (bool *)myArray.get(); + // Use a reference with copy. + int_32 *iarray = setara_c(myLength); + for (int i=0; i<myLength; i++) { + myArrayPointer[i] ? iarray[2*i] = 1 : iarray[2*i] = 0; + } + lcmppl_c(&(this->addr), iset, myLength, 5, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, ComplexPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << key << ") has zero length(1)"; + throw LCMexception(hsmg.str()); + } + complex<float_32> *myArrayPointer = (complex<float_32> *)myArray.get(); + // Use a reference with copy. + int_32 *iarray = setara_c(2*myLength); + for (int i=0; i<myLength; i++) { + iarray[2*i] = (int_32)myArrayPointer[i].real(); + iarray[1+2*i] = (int_32)myArrayPointer[i].imag(); + } + lcmppd_c(&(this->addr), (char *)key.c_str(), myLength, 6, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const int_32 iset, ComplexPtr myArray, const int_32 myLength) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } else if (myLength <= 0) { + hsmg << "put(" << iset << ") has zero length(2)"; + throw LCMexception(hsmg.str()); + } + complex<float_32> *myArrayPointer = (complex<float_32> *)myArray.get(); + // Use a reference with copy. + int_32 *iarray = setara_c(2*myLength); + for (int i=0; i<myLength; i++) { + iarray[2*i] = (int_32)myArrayPointer[i].real(); + iarray[1+2*i] = (int_32)myArrayPointer[i].imag(); + } + lcmppl_c(&(this->addr), iset, myLength, 6, iarray); + myArray.reset(); + return; +} + +void ganlib::Clcm::put(const std::string key, ClcmPtr myClcm) { + if (this->getAccess() != 1) { + hsmg << "put(" << key << ") forbidden if the object is not open in modification mode(1)"; + throw LCMexception(hsmg.str()); + } + lcm *daughter = lcmgid_c(&(this->addr), (char *)key.c_str()); + lcm *myLcm = myClcm->addr; + lcmequ_c(&myLcm, &daughter); + return; +} + +void ganlib::Clcm::put(const int_32 iset, ClcmPtr myClcm) { + if (this->getAccess() != 1) { + hsmg << "put(" << iset << ") forbidden if the object is not open in modification mode(2)"; + throw LCMexception(hsmg.str()); + } + lcm *daughter = lcmgil_c(&(this->addr), iset); + lcm *myLcm = myClcm->addr; + lcmequ_c(&myLcm, &daughter); + return; +} + +lcm *ganlib::Clcm::extract() { + return this->addr; +} |