bool Document::SetCell(Address const& rAddr, Cell::SPtr spCell, bool Force)
{
Address::List ErasedAddresses;
if (!m_spDatabase->SetCellData(rAddr, *spCell->GetData(), ErasedAddresses, Force))
return false;
RemoveLabelIfNeeded(rAddr);
for (Address const& rErsdAddr : ErasedAddresses)
if (GetCell(rErsdAddr) == nullptr)
{
if (HasCrossReferenceTo(rErsdAddr))
RemoveCrossReference(rErsdAddr);
if (HasCrossReferenceFrom(rErsdAddr))
{
auto Label = GetLabelFromAddress(rErsdAddr);
if (Label.GetType() != Label::Unknown)
{
m_LabelUpdatedSignal(rErsdAddr, Label, true);
}
}
}
Address::List AddressList;
AddressList.push_back(rAddr);
AddressList.merge(ErasedAddresses);
m_DocumentUpdatedSignal();
m_AddressUpdatedSignal(AddressList);
return true;
}
bool XRefs::From(Address const& rTo, Address::List& rFromList) const
{
auto const& rLeft = m_XRefs.left;
auto itXRef = rLeft.find(rTo);
for (; itXRef != std::end(rLeft) && itXRef->first == rTo; ++itXRef)
rFromList.push_back(itXRef->second);
return !rFromList.empty();
}
bool Document::DeleteCell(Address const& rAddr)
{
if (!m_spDatabase->DeleteCellData(rAddr))
return false;
Address::List DelAddr;
DelAddr.push_back(rAddr);
m_AddressUpdatedSignal(DelAddr);
m_DocumentUpdatedSignal();
RemoveLabelIfNeeded(rAddr);
return true;
}
////////////////////////////////////////////////////////////////////////////////////
///
/// \brief Returns a list of connections to other components.
///
////////////////////////////////////////////////////////////////////////////////////
Address::List JUDP::GetConnections() const
{
Mutex::ScopedLock lock(&mClientsMutex);
Address::List results;
std::map<Address, CxUtils::UdpClient *>::const_iterator client;
for(client = mClients.begin();
client != mClients.end();
client++)
{
results.push_back(client->first);
}
return results;
}
////////////////////////////////////////////////////////////////////////////////////
///
/// \return List of manually created connections to JAUS components. These
/// are connections not made through the discovery process and cannot
/// be closed through discovery either (only manually).
///
////////////////////////////////////////////////////////////////////////////////////
Address::List JUDP::GetManualConnections() const
{
Address::List copy;
{
Mutex::ScopedLock lock(&mClientsMutex);
std::map<Address, bool>::const_iterator p;
for(p = mPermanentConnections.begin();
p != mPermanentConnections.end();
p++)
{
copy.push_back(p->first);
}
}
return copy;
}
////////////////////////////////////////////////////////////////////////////////////
///
/// \return List of all components currently controlled by the service.
///
////////////////////////////////////////////////////////////////////////////////////
Address::List AccessControl::GetControlledComponents() const
{
Mutex::ScopedLock lock(&mControlMutex);
Address::List result;
std::map<Address, bool>::const_iterator flags;
for(flags = mControlFlags.begin();
flags != mControlFlags.end();
flags++)
{
if(flags->second)
{
result.push_back(flags->first);
}
}
return result;
}
////////////////////////////////////////////////////////////////////////////////////
///
/// \brief Gets the Subsystem::Configuration of the subsystem.
///
////////////////////////////////////////////////////////////////////////////////////
Address::List Subsystem::GetAddressList() const
{
Address::List results;
Configuration::const_iterator node;
for(node = mConfiguration.begin();
node != mConfiguration.end();
node++)
{
Component::Set::const_iterator component;
for(component = node->second.begin();
component != node->second.end();
component++)
{
results.push_back(component->mID);
}
}
return results;
}
bool Document::SetMultiCell(Address const& rAddr, MultiCell* pMultiCell, bool Force)
{
if (Force == false)
{
MultiCell::Map::iterator itMultiCell = m_MultiCells.find(rAddr);
if (itMultiCell != m_MultiCells.end())
return false;
}
m_MultiCells[rAddr] = pMultiCell;
m_spDatabase->AddMultiCell(rAddr, *pMultiCell);
m_DocumentUpdatedSignal();
Address::List AddressList;
AddressList.push_back(rAddr);
m_AddressUpdatedSignal(AddressList);
return true;
}
void FormatDisassembly::operator()(Address::List const& rAddresses, u32 Flags)
{
m_rPrintData.Clear();
if (rAddresses.empty())
return;
m_rPrintData.PrependAddress(Flags & ShowAddress ? true : false);
for (auto const& CurAddr : rAddresses)
_Format(CurAddr, Flags);
}
////////////////////////////////////////////////////////////////////////////////////
///
/// \param[in] name Name of Service to look for.
///
/// \return List of component IDs for those supporting a specific Service.
///
////////////////////////////////////////////////////////////////////////////////////
Address::List Subsystem::GetComponentsWithService(const std::string& name) const
{
Address::List results;
Configuration::const_iterator node;
for(node = mConfiguration.begin();
node != mConfiguration.end();
node++)
{
Component::Set::const_iterator component;
for(component = node->second.begin();
component != node->second.end();
component++)
{
Service::ID::Set::const_iterator service;
service = component->mServices.find(Service::ID(name));
if(service != component->mServices.end())
{
results.push_back(component->mID);
}
}
}
return results;
}
bool ResourceSql::save(Ticket *)
{
// we have to delete all entries for this user and reinsert them
QSqlQuery query("select addressId from kaddressbook_main_" + mUser);
while(query.next())
{
QString addrId = query.value(0).toString();
QSqlQuery q;
q.exec("DELETE FROM kaddressbook_emails WHERE addressId = '" + addrId + "'");
q.exec("DELETE FROM kaddressbook_phones WHERE addressId = '" + addrId + "'");
q.exec("DELETE FROM kaddressbook_addresses WHERE addressId = '" + addrId + "'");
q.exec("DELETE FROM kaddressbook_categories WHERE addressId = '" + addrId + "'");
q.exec("DELETE FROM kaddressbook_customs WHERE addressId = '" + addrId + "'");
q.exec("DELETE FROM kaddressbook_main_" + mUser + " WHERE addressId = '" + addrId + "'");
}
// let's start...
AddressBook::Iterator it;
for(it = addressBook()->begin(); it != addressBook()->end(); ++it)
{
if((*it).resource() != this && (*it).resource() != 0) // save only my and new entries
continue;
QString uid = (*it).uid();
query.exec("INSERT INTO kaddressbook_main_" + mUser + " VALUES ('" + (*it).uid() + "','" + (*it).name() + "','" + (*it).familyName() + "','"
+ (*it).givenName() + "','" + (*it).additionalName() + "','" + (*it).prefix() + "','" + (*it).suffix() + "','" + (*it).nickName()
+ "','" + (*it).birthday().toString(Qt::ISODate) + "','" + (*it).mailer() + "','" + QString::number((*it).timeZone().offset())
+ "','" + QString::number((*it).geo().latitude()) + "','" + QString::number((*it).geo().longitude()) + "','" + (*it).title()
+ "','" + (*it).role() + "','" + (*it).organization() + "','" + (*it).note() + "','" + (*it).productId() + "','"
+ (*it).revision().toString(Qt::ISODate) + "','" + (*it).sortString() + "','" + (*it).url().url() + "')");
// emails
{
QStringList emails = (*it).emails();
QStringList::ConstIterator it;
bool preferred = true;
for(it = emails.begin(); it != emails.end(); ++it)
{
query.exec("INSERT INTO kaddressbook_emails VALUES ('" + uid + "','" + (*it) + "','" + QString::number(preferred) + "')");
preferred = false;
}
}
// phonenumbers
{
PhoneNumber::List phoneNumberList = (*it).phoneNumbers();
PhoneNumber::List::ConstIterator it;
for(it = phoneNumberList.begin(); it != phoneNumberList.end(); ++it)
{
query.exec("INSERT INTO kaddressbook_phones VALUES ('" + uid + "','" + (*it).number() + "','" + QString::number((*it).type()) + "')");
}
}
// postal addresses
{
Address::List addressList = (*it).addresses();
Address::List::ConstIterator it;
for(it = addressList.begin(); it != addressList.end(); ++it)
{
query.exec("INSERT INTO kaddressbook_addresses VALUES ('" + uid + "','" + (*it).postOfficeBox() + "','" + (*it).extended() + "','"
+ (*it).street() + "','" + (*it).locality() + "','" + (*it).region() + "','" + (*it).postalCode() + "','" + (*it).country()
+ "','" + (*it).label() + "','" + QString::number((*it).type()) + "')");
}
}
// categories
{
QStringList categories = (*it).categories();
QStringList::ConstIterator it;
for(it = categories.begin(); it != categories.end(); ++it)
query.exec("INSERT INTO kaddressbook_categories VALUES ('" + uid + "','" + (*it) + "')");
}
// customs
{
QStringList list = (*it).customs();
QStringList::ConstIterator it;
for(it = list.begin(); it != list.end(); ++it)
{
int dashPos = (*it).find('-');
int colonPos = (*it).find(':');
QString app = (*it).left(dashPos);
QString name = (*it).mid(dashPos + 1, colonPos - dashPos - 1);
QString value = (*it).right((*it).length() - colonPos - 1);
query.exec("INSERT INTO kaddressbook_categories VALUES ('" + uid + "','" + app + "','" + name + "','" + value + "')");
}
}
}
return true;
}
// TODO: make list a const&
QString VCardTool::createVCards(Addressee::List list, VCard::Version version)
{
VCard::List vCardList;
Addressee::List::ConstIterator addrIt;
Addressee::List::ConstIterator listEnd(list.constEnd());
for(addrIt = list.constBegin(); addrIt != listEnd; ++addrIt)
{
VCard card;
QStringList::ConstIterator strIt;
// ADR + LABEL
const Address::List addresses = (*addrIt).addresses();
for(Address::List::ConstIterator it = addresses.begin(); it != addresses.end(); ++it)
{
QStringList address;
bool isEmpty = ((*it).postOfficeBox().isEmpty() && (*it).extended().isEmpty() && (*it).street().isEmpty() && (*it).locality().isEmpty()
&& (*it).region().isEmpty() && (*it).postalCode().isEmpty() && (*it).country().isEmpty());
address.append((*it).postOfficeBox().replace(';', "\\;"));
address.append((*it).extended().replace(';', "\\;"));
address.append((*it).street().replace(';', "\\;"));
address.append((*it).locality().replace(';', "\\;"));
address.append((*it).region().replace(';', "\\;"));
address.append((*it).postalCode().replace(';', "\\;"));
address.append((*it).country().replace(';', "\\;"));
VCardLine adrLine("ADR", address.join(";"));
if(version == VCard::v2_1 && needsEncoding(address.join(";")))
{
adrLine.addParameter("charset", "UTF-8");
adrLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
VCardLine labelLine("LABEL", (*it).label());
if(version == VCard::v2_1 && needsEncoding((*it).label()))
{
labelLine.addParameter("charset", "UTF-8");
labelLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
bool hasLabel = !(*it).label().isEmpty();
QMap< QString, int >::ConstIterator typeIt;
for(typeIt = mAddressTypeMap.constBegin(); typeIt != mAddressTypeMap.constEnd(); ++typeIt)
{
if(typeIt.data() & (*it).type())
{
adrLine.addParameter("TYPE", typeIt.key());
if(hasLabel)
labelLine.addParameter("TYPE", typeIt.key());
}
}
if(!isEmpty)
card.addLine(adrLine);
if(hasLabel)
card.addLine(labelLine);
}
// AGENT
card.addLine(createAgent(version, (*addrIt).agent()));
// BDAY
card.addLine(VCardLine("BDAY", createDateTime((*addrIt).birthday())));
// CATEGORIES
if(version == VCard::v3_0)
{
QStringList categories = (*addrIt).categories();
QStringList::Iterator catIt;
for(catIt = categories.begin(); catIt != categories.end(); ++catIt)
(*catIt).replace(',', "\\,");
VCardLine catLine("CATEGORIES", categories.join(","));
if(version == VCard::v2_1 && needsEncoding(categories.join(",")))
{
catLine.addParameter("charset", "UTF-8");
catLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(catLine);
}
// CLASS
if(version == VCard::v3_0)
{
card.addLine(createSecrecy((*addrIt).secrecy()));
}
// EMAIL
const QStringList emails = (*addrIt).emails();
bool pref = true;
for(strIt = emails.begin(); strIt != emails.end(); ++strIt)
{
VCardLine line("EMAIL", *strIt);
if(pref == true && emails.count() > 1)
{
line.addParameter("TYPE", "PREF");
pref = false;
}
card.addLine(line);
}
// FN
VCardLine fnLine("FN", (*addrIt).formattedName());
if(version == VCard::v2_1 && needsEncoding((*addrIt).formattedName()))
{
fnLine.addParameter("charset", "UTF-8");
fnLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(fnLine);
// GEO
Geo geo = (*addrIt).geo();
if(geo.isValid())
{
QString str;
str.sprintf("%.6f;%.6f", geo.latitude(), geo.longitude());
card.addLine(VCardLine("GEO", str));
}
// KEY
const Key::List keys = (*addrIt).keys();
Key::List::ConstIterator keyIt;
for(keyIt = keys.begin(); keyIt != keys.end(); ++keyIt)
card.addLine(createKey(*keyIt));
// LOGO
card.addLine(createPicture("LOGO", (*addrIt).logo()));
// MAILER
VCardLine mailerLine("MAILER", (*addrIt).mailer());
if(version == VCard::v2_1 && needsEncoding((*addrIt).mailer()))
{
mailerLine.addParameter("charset", "UTF-8");
mailerLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(mailerLine);
// N
QStringList name;
name.append((*addrIt).familyName().replace(';', "\\;"));
name.append((*addrIt).givenName().replace(';', "\\;"));
name.append((*addrIt).additionalName().replace(';', "\\;"));
name.append((*addrIt).prefix().replace(';', "\\;"));
name.append((*addrIt).suffix().replace(';', "\\;"));
VCardLine nLine("N", name.join(";"));
if(version == VCard::v2_1 && needsEncoding(name.join(";")))
{
nLine.addParameter("charset", "UTF-8");
nLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(nLine);
// NAME
VCardLine nameLine("NAME", (*addrIt).name());
if(version == VCard::v2_1 && needsEncoding((*addrIt).name()))
{
nameLine.addParameter("charset", "UTF-8");
nameLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(nameLine);
// NICKNAME
if(version == VCard::v3_0)
card.addLine(VCardLine("NICKNAME", (*addrIt).nickName()));
// NOTE
VCardLine noteLine("NOTE", (*addrIt).note());
if(version == VCard::v2_1 && needsEncoding((*addrIt).note()))
{
noteLine.addParameter("charset", "UTF-8");
noteLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(noteLine);
// ORG
QStringList organization;
organization.append((*addrIt).organization().replace(';', "\\;"));
if(!(*addrIt).department().isEmpty())
organization.append((*addrIt).department().replace(';', "\\;"));
VCardLine orgLine("ORG", organization.join(";"));
if(version == VCard::v2_1 && needsEncoding(organization.join(";")))
{
orgLine.addParameter("charset", "UTF-8");
orgLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(orgLine);
// PHOTO
card.addLine(createPicture("PHOTO", (*addrIt).photo()));
// PROID
if(version == VCard::v3_0)
card.addLine(VCardLine("PRODID", (*addrIt).productId()));
// REV
card.addLine(VCardLine("REV", createDateTime((*addrIt).revision())));
// ROLE
VCardLine roleLine("ROLE", (*addrIt).role());
if(version == VCard::v2_1 && needsEncoding((*addrIt).role()))
{
roleLine.addParameter("charset", "UTF-8");
roleLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(roleLine);
// SORT-STRING
if(version == VCard::v3_0)
card.addLine(VCardLine("SORT-STRING", (*addrIt).sortString()));
// SOUND
card.addLine(createSound((*addrIt).sound()));
// TEL
const PhoneNumber::List phoneNumbers = (*addrIt).phoneNumbers();
PhoneNumber::List::ConstIterator phoneIt;
for(phoneIt = phoneNumbers.begin(); phoneIt != phoneNumbers.end(); ++phoneIt)
{
VCardLine line("TEL", (*phoneIt).number());
QMap< QString, int >::ConstIterator typeIt;
for(typeIt = mPhoneTypeMap.constBegin(); typeIt != mPhoneTypeMap.constEnd(); ++typeIt)
{
if(typeIt.data() & (*phoneIt).type())
line.addParameter("TYPE", typeIt.key());
}
card.addLine(line);
}
// TITLE
VCardLine titleLine("TITLE", (*addrIt).title());
if(version == VCard::v2_1 && needsEncoding((*addrIt).title()))
{
titleLine.addParameter("charset", "UTF-8");
titleLine.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(titleLine);
// TZ
TimeZone timeZone = (*addrIt).timeZone();
if(timeZone.isValid())
{
QString str;
int neg = 1;
if(timeZone.offset() < 0)
neg = -1;
str.sprintf("%c%02d:%02d", (timeZone.offset() >= 0 ? '+' : '-'), (timeZone.offset() / 60) * neg, (timeZone.offset() % 60) * neg);
card.addLine(VCardLine("TZ", str));
}
// UID
card.addLine(VCardLine("UID", (*addrIt).uid()));
// URL
card.addLine(VCardLine("URL", (*addrIt).url().url()));
// VERSION
if(version == VCard::v2_1)
card.addLine(VCardLine("VERSION", "2.1"));
if(version == VCard::v3_0)
card.addLine(VCardLine("VERSION", "3.0"));
// X-
const QStringList customs = (*addrIt).customs();
for(strIt = customs.begin(); strIt != customs.end(); ++strIt)
{
QString identifier = "X-" + (*strIt).left((*strIt).find(":"));
QString value = (*strIt).mid((*strIt).find(":") + 1);
if(value.isEmpty())
continue;
VCardLine line(identifier, value);
if(version == VCard::v2_1 && needsEncoding(value))
{
line.addParameter("charset", "UTF-8");
line.addParameter("encoding", "QUOTED-PRINTABLE");
}
card.addLine(line);
}
vCardList.append(card);
}
return VCardParser::createVCards(vCardList);
}
void VCardFormatImpl::saveAddressee( const Addressee &addressee, VCARD::VCard *v, bool intern )
{
ContentLine cl;
QString value;
addTextValue( v, EntityName, addressee.name() );
addTextValue( v, EntityUID, addressee.uid() );
addTextValue( v, EntityFullName, addressee.formattedName() );
QStringList emails = addressee.emails();
QStringList::ConstIterator it4;
for( it4 = emails.begin(); it4 != emails.end(); ++it4 ) {
addTextValue( v, EntityEmail, *it4 );
}
QStringList customs = addressee.customs();
QStringList::ConstIterator it5;
for( it5 = customs.begin(); it5 != customs.end(); ++it5 ) {
addCustomValue( v, *it5 );
}
addTextValue( v, EntityURL, addressee.url().url() );
addNValue( v, addressee );
addTextValue( v, EntityNickname, addressee.nickName() );
addTextValue( v, EntityMailer, addressee.mailer() );
addTextValue( v, EntityTitle, addressee.title() );
addTextValue( v, EntityRole, addressee.role() );
addTextValue( v, EntityOrganisation, addressee.organization() );
addTextValue( v, EntityNote, addressee.note() );
addTextValue( v, EntityProductID, addressee.productId() );
addTextValue( v, EntitySortString, addressee.sortString() );
Address::List addresses = addressee.addresses();
Address::List::ConstIterator it3;
for( it3 = addresses.begin(); it3 != addresses.end(); ++it3 ) {
addAddressValue( v, *it3 );
addLabelValue( v, *it3 );
}
PhoneNumber::List phoneNumbers = addressee.phoneNumbers();
PhoneNumber::List::ConstIterator it2;
for( it2 = phoneNumbers.begin(); it2 != phoneNumbers.end(); ++it2 ) {
addTelephoneValue( v, *it2 );
}
Key::List keys = addressee.keys();
Key::List::ConstIterator it6;
for( it6 = keys.begin(); it6 != keys.end(); ++it6 ) {
addKeyValue( v, *it6 );
}
addTextValue( v, EntityCategories, addressee.categories().join(",") );
addDateValue( v, EntityBirthday, addressee.birthday().date() );
addDateTimeValue( v, EntityRevision, addressee.revision() );
addGeoValue( v, addressee.geo() );
addUTCValue( v, addressee.timeZone() );
addClassValue( v, addressee.secrecy() );
addPictureValue( v, EntityPhoto, addressee.photo(), addressee, intern );
addPictureValue( v, EntityLogo, addressee.logo(), addressee, intern );
addAgentValue( v, addressee.agent() );
addSoundValue( v, addressee.sound(), addressee, intern );
}