ObjectPtr StringDialog::createNewGeneratedString(){
Q_ASSERT(_document && _document->objectStore());
QString value = _stringTab->value();
// qDebug() << "Creating new string ===>"
// << "\n\ttag:" << DataDialog::tagString()
// << "\n\tvalue:" << value
// << endl;
StringPtr string = _document->objectStore()->createObject<String>();
string->setValue(value);
string->setOrphan(true);
string->setEditable(true);
if (DataDialog::tagStringAuto()) {
string->setDescriptiveName(QString());
} else {
string->setDescriptiveName(DataDialog::tagString());
}
string->writeLock();
string->registerChange();
string->unlock();
_dataObjectName = string->Name();
//UpdateServer::self()->requestUpdateSignal();
return static_cast<ObjectPtr>(string);
}
void DataMatrix::_resetFieldStrings() {
const QMap<QString, QString> meta_strings = dataSource()->matrix().metaStrings(_field);
QStringList fieldStringKeys = _fieldStrings.keys();
// remove field strings that no longer need to exist
readLock();
for (int i=0; i<fieldStringKeys.count(); i++) {
QString key = fieldStringKeys.at(i);
if (!meta_strings.contains(key)) {
StringPtr sp = _fieldStrings[key];
_fieldStrings.remove(key);
sp = 0L;
}
}
// find or insert strings, to set their value
QMapIterator<QString, QString> it(meta_strings);
while (it.hasNext()) {
it.next();
QString key = it.key();
StringPtr sp;
if (!_fieldStrings.contains(key)) { // insert a new one
_fieldStrings.insert(key, sp = store()->createObject<String>());
sp->setProvider(this);
sp->setSlaveName(key);
} else { // find it
sp = _fieldStrings[key];
}
sp->setValue(it.value());
}
unlock();
}
void StringSelector::fillStrings() {
if (!_store) {
return;
}
QHash<QString, StringPtr> strings;
StringList stringList = _store->getObjects<String>();
StringList::ConstIterator it = stringList.constBegin();
for (; it != stringList.constEnd(); ++it) {
StringPtr string = (*it);
string->readLock();
strings.insert(string->CleanedName(), string);
string->unlock();
}
QStringList list = strings.keys();
qSort(list);
StringPtr current = selectedString();
_string->clear();
foreach (const QString &string, list) {
StringPtr s = strings.value(string);
_string->addItem(string, qVariantFromValue(s.data()));
}
void BasicPlugin::setOutputString(const QString &type, const QString &name) {
QString txt = !name.isEmpty() ? name : type;
Q_ASSERT(store());
StringPtr s = store()->createObject<String>();
s->setProvider(this);
s->setSlaveName(txt);
s->setOrphan(false);
_outputStrings.insert(type, s);
}
StringPtr ReplaceAll(StringPtr str, const std::string &remove, StringPtr insert)
{
std::string::size_type pos = 0;
while ((pos = str->find(remove, pos)) != std::string::npos)
{
str->replace(pos, remove.size(), *insert);
pos++;
}
return str;
}
LRESULT C_SpinButton::OnTextChange(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
C_STLException::install();
try {
TCHAR t[32];
m_ed.SendMessage(WM_GETTEXT, 1023, reinterpret_cast<LPARAM>(t));
String s(t);
StringPtr ptr = s.Find(_T('-'));
if (ptr.isValid()) {
if (ptr.Index() > 0) {
s = s.Left(ptr.Index());
m_ed.SendMessage(WM_SETTEXT, s.GetLength(), reinterpret_cast<LPARAM>(s.toLPCTSTR()));
m_ed.SendMessage(EM_SETSEL, s.GetLength(), s.GetLength());
return S_OK;
}
}
float f = static_cast<float>(s.toDouble());
if (m_fValue != f) {
if (m_fMinValue == m_fMaxValue || (f >= m_fMinValue && f <= m_fMaxValue)) {
InternalSetValue(f);
FireChangeMessage();
}
else {
MessageBeep(0xFFFFFFFF);
DisplayValue();
return S_OK;
}
}
if (0 == s.GetLength()) {
DisplayValue();
}
}
catch (C_STLNonStackException const &exception) {
exception.Log(_T("Exception in C_SpinButton::"));
}
return S_OK;
}
void check_starr(int n, const char* A[], const SA& sa) {
ASSERT_EQ(n, sa.length());
for (int i = 0; i < n; ++i) {
std::string p = sa.get_str(i);
ASSERT_EQ(p, A[i]);
}
for (int i = 0; i < n; ++i) {
StringPtr pt = sa.get(i);
unsigned slen = strlen(A[i]);
ASSERT_EQ(slen, pt->length());
ASSERT_EQ(0, strncmp(A[i], pt->c_str(), slen));
}
}
void testPkt()
{
typedef boost::shared_ptr<FreeList<net_pk> > NetPacketFLShrPtr;
NetPacketFLShrPtr pkFL(new FreeList<net_pk>(5, 10));
sPkFList.set(pkFL);
IPacketShrPtr pk = allocPacket();
pk->setMsg(M_JUMP);
pk->put("teststring", 10);
pk->put("teststr2", 8);
StringPtr ms;
pk->get(ms, pk->getSize());
printf("pk: %s\n", ms.ptr());
printf("pk size: %d\n", pk->getSize());
printf("msg: %s\n", g_msgs[pk->getMsg()].c_str());
IPacketParserShrPtr pkpr(new packet_builder);
char str[PKT_MAX_SIZE] = "001400ACTION1#nous|1&4&5&1";
std::vector<IPacketShrPtr> pks;
pkpr->parse(str, 2, pks);
pkpr->parse(str+2, 1, pks);
pkpr->parse(str+3, 1, pks);
pkpr->parse(str+4, 2, pks);
pkpr->parse(str+6, 1, pks);
pkpr->parse(str+7, 2, pks);
pkpr->parse(str+9, 17, pks);
for (uint32 i=0; i<pks.size(); ++i)
{
StringPtr msi;
pks[i]->get(msi, pks[i]->getSize());
printf("pks[i]: %s\n", msi.ptr());
printf("pks[i] size: %d\n", pks[i]->getSize());
printf("msg: %s\n", g_msgs[pks[i]->getMsg()].c_str());
Args args_list;
packet_seer psr;
pks[i]->reset();
psr.analyse_packet(pks[i], args_list, g_spts);
std::vector<Arg>& args = args_list.argList;
for (uint32 i=0; i<args.size(); ++i)
{
printf("args[%d]: arg: %s\n", i, args[i].arg.c_str());
}
}
getchar();
}
// Emit constants
ValueBuilder BlockBuilder::createStringConst(const String& value) {
StringPtr type = StringType::get(getNativeContext());
// get partial types for string
llvm::Type* charType = llvm::IntegerType::get(*m_context, 16);
llvm::Type* sizeType = llvm::IntegerType::get(*m_context, 32);
llvm::ArrayType* bufferType = llvm::ArrayType::get(charType, value.length());
// generate size
llvm::Constant* size = llvm::ConstantInt::get(*m_context, llvm::APInt(32, value.length(), false));
// generate buffer
llvm::Constant* buffer = 0; {
std::vector<llvm::Constant*> bufferConst;
for (int i = 0; i < value.length(); ++i) {
UChar c = value[i];
llvm::Constant* value = llvm::ConstantInt::get(*m_context, llvm::APInt(16, c, false));
bufferConst.push_back(value);
}
buffer = llvm::ConstantArray::get(bufferType, bufferConst);
}
// generate string type
std::vector<llvm::Type*> elements;
elements.push_back(sizeType);
elements.push_back(bufferType);
llvm::StructType* stringCstType = llvm::StructType::get(*m_context, elements);
// generate string
llvm::Constant* string = llvm::ConstantStruct::get(stringCstType, size, buffer, NULL);
llvm::GlobalVariable* stringCst = new llvm::GlobalVariable(
*m_module,
stringCstType,
true,
llvm::GlobalValue::PrivateLinkage,
string,
"string.cst"
);
stringCst->setUnnamedAddr(true); // Binary equal strings must be merged
llvm::Type* stringType = type->getMetadata()->getBackendVariableType();
llvm::Value* result = new llvm::BitCastInst(stringCst, stringType, "string.val", m_block);
return ValueBuilder(*this, result, type);
}
void StringSelector::setSelectedString(StringPtr selectedString) {
int i=-1;
for (int j=0; j<_string->count() ; ++j) {
if (selectedString.data() == _string->itemData(j).value<String*>()) {
i=j;
break;
}
}
Q_ASSERT(i != -1);
_string->setCurrentIndex(i);
}
void StringSelector::setSelectedString(StringPtr selectedString) {
int i=-1,j;
for (j=0; j<_string->count() ; j++) {
if (selectedString.data() == (qVariantValue<String*>(_string->itemData(j)))) {
i=j;
break;
}
}
Q_ASSERT(i != -1);
_string->setCurrentIndex(i);
}
ParsedEntity::ParsedEntity(StringPtr content)
{
const char * cContent = content->c_str();
shared_ptr<cJSON> jsonPtr(cJSON_Parse(cContent), null_deleter());
json.swap(jsonPtr);
if(json && json->string)
{
key = MakeStringPtr(json->string);
}
else
{
key = MakeStringPtr("");
}
type = determineType();
}
/** combines tow functions
* @param result the combined inputs
*/
void combine(
boost::shared_ptr<libpipe::ctc::SharedData<std::string> > result)
{
result->get()->append(*input1_->get());
result->get()->append(*input2_->get());
}
ParsedEntityPtr ParsedEntity::getObjectValue(StringPtr key)
{
cJSONPtr ret(cJSON_GetObjectItem(json.get(), key->c_str()), null_deleter());
return MakeParsedEntity(ret);
}
foreach (StringPtr P, _inputStrings) {
minSerial = qMin(minSerial, P->serial());
}
STDMETHODIMP C_Items::Retrieve(I_Archive * arc)
{
if (!arc)
return E_POINTER;
C_STLException::install();
//TODO - templatize this function and stick it in a base class.
try {
BSTR bs = NULL;
unsigned int len = 0;
if (S_OK != arc->RetrieveString(&bs)) {
return E_FAIL;
}
String s(bs);
s.toLower();
String::FreeBSTR(&bs);
static String tags[5] = {
_T("mmp:item"),
_T("mmp:text"),
_T("mmp:node"),
_T("mmp:picture"),
_T("mmp:branch")
};
typedef enum ematches {
plainitem,
text,
node,
picture,
branch
};
static String types[4] = {
_T("node"),
_T("text-block"),
_T("picture"),
_T("branch")
};
ematches match = plainitem;
CLSID clsid;
IID iid;
StringPtr ptr(s.Find(tags[plainitem]));
StringPtr ptrKill(s.Find(tags[plainitem]));
for (unsigned int test = plainitem; test <= branch; test++) {
ptr = s.Find(tags[test]);
if (ptr.isValid()) {
ptrKill = s.Find(String(_T("/")) + tags[test]);
match = static_cast<ematches>(test);
break;
}
}
switch (match) {
case node:
clsid = CLSID_Node;
iid = IID_I_Node;
break;
case text:
clsid = CLSID_TextBlock;
iid = IID_I_TextBlock;
break;
case picture:
clsid = CLSID_Picture;
iid = IID_I_Picture;
break;
case branch:
clsid = CLSID_Branch;
iid = IID_I_Branch;
break;
}
while (ptr.isValid() && !ptrKill.isValid()) {//Check this is the start of an item...
C_ItemPtr item;
/////////////////////////////////////////////////////
// In a paste operation, the object's GUID must be ignored
// - a new object is being created with its own identity.
BOOL b = FALSE;
BOOL bPreserveID = TRUE;
BSTR bs = NULL;
arc->get_PreserveIdentities(&bPreserveID);
if (bPreserveID) {
/////////////////////////////////////////////////////
// Get the GUID to identify the object. Check if it
// exists already - if so, divert the serialisation data
// to the existing object and add a reference to the
// Children collection.
String sUUID;
StringPtr ptrUUID = s.Find(_T("uuid"));
if (ptrUUID.isValid()) {
StringPtr ptrLeft = s.Find(_T("\""), ptrUUID);
ptrLeft++;
if (ptrLeft.isValid()) {
StringPtr ptrRight = s.Find(_T("\""), ptrLeft);
if (ptrRight.isValid()) {
sUUID = s.Mid(ptrLeft.Index(), ptrRight.Index() - ptrLeft.Index());
}
else {
sUUID = s.Right(s.GetLength() - ptrLeft.Index());
}
T_SafeArray<char> buffer(sUUID.GetLength() + 1);
::_stprintf(buffer[0], _T("%s\0"), sUUID.toLPCTSTR());
GUID guid = String(buffer[0]).toGUID();
map<GUID, I_MapItem*>::iterator it = m_S_Items.find(guid);
if (it != m_S_Items.end()) {
//The object with this GUID already exists in the item map
item = (*it).second;
_ASSERTE(item);
if (item) {
VARIANT v;
C_UniquePtr unique(item);
if (unique) {
unique->get_UID(&bs);
}
VariantInit(&v);
v.vt = VT_BSTR;
v.bstrVal = bs;
get_Exists(v, &b);
if (!b) {
// Add the item to the collection
Add(bs, item);
b = TRUE;
}
}
}
}
}
}
if (b) {
if (bs) {
String::FreeBSTR(&bs);
}
}
else {
if (match == plainitem) {
int type = -1;
StringPtr ptrType = s.Find(_T("type"));
String sType;
if (ptrType.isValid()) {
StringPtr ptrLeft = s.Find(_T("\""), ptrType);
if (ptrLeft.isValid()) {
ptrLeft++;
StringPtr ptrRight = s.Find(_T("\""), ptrLeft);
if (ptrRight.isValid()) {
sType = s.Mid(ptrLeft.Index(), ptrRight.Index() - ptrLeft.Index());
}
else {
sType = s.Right(s.GetLength() - ptrLeft.Index());
}
for (int n = 0; n < 4; n++) {
if (sType == types[n]) {
type = n;
switch (type) {
case 0:
clsid = CLSID_Node;
iid = IID_I_Node;
break;
case 1:
clsid = CLSID_TextBlock;
iid = IID_I_TextBlock;
break;
case 2:
clsid = CLSID_Picture;
iid = IID_I_Picture;
break;
case 3:
clsid = CLSID_Branch;
iid = IID_I_Branch;
break;
}
break;
}
}
}
}
if (type < 0) {
/////////////////////////////////////////////////////
// Get the CLSID and IID to identify the object's type
String sCLSID;
StringPtr ptrCLSID = s.Find(_T("clsid"));
StringPtr ptrLeft = s.Find(_T("\""), ptrCLSID);
ptrLeft++;
StringPtr ptrRight = s.Find(_T("\""), ptrLeft);
if (ptrRight.isValid()) {
sCLSID = s.Mid(ptrLeft.Index(), ptrRight.Index() - ptrLeft.Index());
}
else {
sCLSID = s.Right(s.GetLength() - ptrLeft.Index());
}
bs = sCLSID.toBSTR();
CLSIDFromString(bs, &clsid);
String::FreeBSTR(&bs);
String sIID;
StringPtr ptrIID = s.Find(_T("iid"));
ptrLeft = s.Find(_T("\""), ptrIID);
ptrLeft++;
ptrRight = s.Find(_T("\""), ptrLeft);
if (ptrRight.isValid()) {
sIID = s.Mid(ptrLeft.Index(), ptrRight.Index() - ptrLeft.Index());
}
else {
sIID = s.Right(s.GetLength() - ptrLeft.Index());
}
bs = sIID.toBSTR();
IIDFromString(bs, &iid);
String::FreeBSTR(&bs);
}
}
// TODO: Drop the string parameter
item = NewItem(clsid, iid, String(_T("")));
}
if (item) {
arc->Rollback();
C_PersistentPtr persist(item);
if (persist) {
persist->Serialise(arc);
C_DrawingStrategyPtr strategy(item);
if (strategy) {
strategy->putref_Parent(m_pParent);
}
BOOL bHasFocus = FALSE;
item->get_HasFocus(&bHasFocus);
if (bHasFocus) {
I_ECBDiagram *map = NULL;
if (m_pParent) {
m_pParent->get_Map(&map);
}
if (map) {
map->putref_CurrentSelection(item);
map->Release();
}
}
}
}
if (match == plainitem) {
// Discard closing tag
if (S_OK != arc->RetrieveString(&bs)) {
return E_FAIL;
}
s = bs;
String::FreeBSTR(&bs);
s = s.toLower();
ptr = s.Find(tags[match]);
ptrKill = s.Find(String(_T("/")) + tags[match]);
}
else {
break;
}
}
if (match == plainitem && !ptrKill.isValid()) {
//...if it isn't, it doesn't belong here!
arc->Rollback();
}
// Sort the items as soon as they're retrieved
Sort();
}
catch (C_STLNonStackException const &exception) {
exception.Log(_T("Exception in C_Items::Retrieve"));
}
return S_OK;
}
void Scanner::debug_set_input_string(StringPtr input) {
// for testing purposes only
// breaks encapsulation
this->file_buf_ptr = input;
this->file_ptr = input->begin();
}
void WebInterface::worker() {
/* Backup the stdio streambufs */
std::streambuf * cin_streambuf = std::cin.rdbuf();
std::streambuf * cout_streambuf = std::cout.rdbuf();
std::streambuf * cerr_streambuf = std::cerr.rdbuf();
const std::string kw_title(KW_TITLE);
const std::string kw_head(KW_HEAD);
const std::string kw_menu(KW_MENU);
const std::string kw_content(KW_CONTENT);
FCGX_Request request;
/* Initialize FastCGI library and request */
FCGX_Init();
FCGX_InitRequest(&request, 0, FCGI_FAIL_ACCEPT_ON_INTR);
LOG_DBG("FastCGI initialization success!");
while (!stop_flag_) {
if(FCGX_Accept_r(&request) >= 0) {
fcgi_streambuf cin_fcgi_streambuf(request.in);
fcgi_streambuf cout_fcgi_streambuf(request.out);
fcgi_streambuf cerr_fcgi_streambuf(request.err);
std::cin.rdbuf(&cin_fcgi_streambuf);
std::cout.rdbuf(&cout_fcgi_streambuf);
std::cerr.rdbuf(&cerr_fcgi_streambuf);
/* getting the uri from the request */
std::string uri;
const char *uri_param = FCGX_GetParam("REQUEST_URI", request.envp);
if(!uri_param) {
LOG_ERR("Failed to retrieve the request URI environment value!");
uri = URI_PAGE_ERROR;
} else {
uri = uri_param;
}
LOG_DBG("Request received: %s", uri.c_str());
/* Check if URI is a file in the home folder and get the mime of
* that file (by extension) */
std::string path;
std::string mime = if_file_get_mime(uri, &path);
if (!mime.empty()) {
/* This is a file we need to serve */
StringPtr file_data = Utils::read_file(path);
std::cout << "Content-type: " << mime << "\r\n\r\n";
std::cout << *(file_data);
file_data.reset();
} else {
/* Parse the URI */
std::map<std::string, std::string> uri_data = parseURI(uri);
LOG_DBG("URI Parsed, page requested: %s",
uri_data[URI_PAGE].c_str());
/* Generate and serve the page depending on the URI */
StringPtr page;
std::string content_type = "text/html";
/* Main page requested */
if (uri_data[URI_PAGE].compare(URI_PAGE_MAIN) == 0) {
bool success = false;
/* Check if a command was sent from the client. */
if (uri_data.find(URI_PAGE_COMMAND) != uri_data.end()) {
success = add_command(uri_data[URI_PAGE_COMMAND]);
}
std::string s;
/* Check if the request was sent from javascript or pure HTML */
if(uri_data.find(URI_PAGE_SOURCE) != uri_data.end()) {
LOG_DBG("This query's source IS javascript: %s, Source: %s",
uri.c_str(), (uri_data[URI_PAGE_SOURCE]).c_str());
content_type = "application/json";
page = generate_command_json(success);
} else {
LOG_DBG("This query's source IS NOT javascript: %s", uri.c_str());
/* Just generate a standard main page */
page = generate_main_page();
}
/* Log page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_LOG) == 0) {
page = generate_log_page();
/* Status page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_STATUS) == 0) {
page = generate_status_page();
/* Console lines JSON page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_CL) == 0) {
if (uri_data.find(URI_PAGE_BEFORE) != uri_data.end()) {
content_type = "application/json";
page = generate_cljson_before(
uri_data[URI_PAGE_BEFORE]);
} else if (uri_data.find(URI_PAGE_AFTER)
!= uri_data.end()) {
content_type = "application/json";
page = generate_cljson_after(uri_data[URI_PAGE_AFTER]);
} else {
page = generate_error_page();
}
/* Log lines JSON page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_LL) == 0) {
if (uri_data.find(URI_PAGE_BEFORE) != uri_data.end()) {
content_type = "application/json";
page = generate_lljson_before(
uri_data[URI_PAGE_BEFORE]);
} else if (uri_data.find(URI_PAGE_AFTER)
!= uri_data.end()) {
content_type = "application/json";
page = generate_lljson_after(uri_data[URI_PAGE_AFTER]);
} else {
page = generate_error_page();
}
} else {
page = generate_error_page();
}
/* Output the generated page with the correct content type */
std::cout << "Content-type: " << content_type << "\r\n\r\n";
std::cout << *(page.get());
}
}
else {
LOG_TRC("FCGX_Aceept_r returned less than 0!");
}
}
LOG_TRC("Out of accept request loop!");
// Free request strucure
FCGX_Finish_r(&request);
// Flag the thread as not running anymore.
running_ = false;
// restore stdio streambufs
std::cin.rdbuf(cin_streambuf);
std::cout.rdbuf(cout_streambuf);
std::cerr.rdbuf(cerr_streambuf);
}
STDMETHODIMP C_FloodedFill::Retrieve(I_Archive *arc)
{
C_STLException::install();
try {
BSTR bs = NULL;
if (S_OK != arc->RetrieveString(&bs)) {
return E_FAIL;
}
String s(bs);
String::FreeBSTR(&bs);
static String enditem(_T("/mmp:item"));
static String fill(_T("mmp:floodfill"));
static String endfill(_T("/mmp:floodfill"));
while (!s.toLower().Find(endfill).isValid()) {
StringPtr ptrItem = s.Find(enditem);
if (ptrItem.isValid()) {
arc->Rollback();
break;
}
StringPtr ptrStart = s.Find(fill);
if (ptrStart.isValid()) {
StringPtr ptrStyle = s.Find(_T("colours"));
StringPtr ptrLeft = s.Find(_T("\""), ptrStyle);
if (ptrLeft.isValid()) {
ptrLeft++;
StringPtr ptrRight = s.Find(_T("\""), ptrLeft);
if (ptrRight.isValid()) {
String style = s.Mid(ptrLeft.Index(), ptrRight.Index() - ptrLeft.Index());
if (style.GetLength() > 0) {
T_PointerArray<String> sa;
style.Split(_T(':'), &sa);
m_nCount = sa.GetLength();
m_saColours.ReDim(m_nCount);
for (int n = 0; n < m_nCount; n++) {
*m_saColours[n] = sa[n]->toInteger();
}
}
}
}
}
else {
arc->Rollback();
EatTag(arc);
}
if (S_OK != arc->RetrieveString(&bs)) {
return E_FAIL;
}
s = bs;
String::FreeBSTR(&bs);
}
}
catch (C_STLNonStackException const &exception) {
exception.Log(_T("Exception in C_floodFill::Retrieve"));
}
return S_OK;
}
foreach (StringPtr s, objectStore()->getObjects<String>()) {
s->save(xml);
}
StringPtr Arena::copyString(StringPtr content) {
char* data = reinterpret_cast<char*>(allocateBytes(content.size() + 1, 1, false));
memcpy(data, content.cStr(), content.size() + 1);
return StringPtr(data, content.size());
}
