void MeshObject::readObj(const char* objName)
{
FILE *obj = fopen(objName,"r");
char buffer[MAX_LINE_SIZE];
if (obj)
{
while (fgets(buffer,MAX_LINE_SIZE,obj))
getNextElement(buffer);
}
}
void CircularBuffer::addRawValue(const RawValue::Data *value)
{
#ifdef DEBUG_CIRCBUF
printf("CircularBuffer(0x%lX)::add: ", (unsigned long)this);
RawValue::show(stdout, type, count, value);
#endif
if (!isValidTime(RawValue::getTime(value)))
{
LOG_MSG("CircularBuffer added bad time stamp!\n");
}
memcpy(getNextElement(), value, element_size);
}
int HRSstreamNext(HRSstream_t s, char *data)
{
int bytesread;
if (s->filterOnly) {
return getNextElement(s, data);
}
else { /* sorted stream */
bytesread = sfread(s->lfp, data, s->logicalSize);
if (bytesread == 0)
return 0;
else if (bytesread != s->logicalSize) {
HRSerrorExit1("stream read from %s failed.\n", s->streamName);
/* won't get here */
return 0;
}
else return 1;
}
}
int main(int argc, char* argv[])
{
if (argc != 3)
{
std::cerr << "usage: PListMerger"
<< " <first-plist-content>"
<< " <second-plist-content>" << std::endl;
return 1;
}
const std::vector<std::string> args{argv, argv + argc};
const juce::ScopedPointer<juce::XmlElement> firstPlistElement =
juce::XmlDocument::parse(args.at(1));
if (!firstPlistElement || !firstPlistElement->hasTagName("plist"))
{
std::cerr << "Invalid first plist content, expected <plist> element" << std::endl;
return 1;
}
const auto firstDictElement = firstPlistElement->getChildByName("dict");
if (!firstDictElement)
{
std::cerr << "Invalid first plist content, expected <dict> element" << std::endl;
return 1;
}
std::vector<std::string> keysInFirstPlist;
for (auto childElement = firstDictElement->getFirstChildElement();
childElement != nullptr; childElement = childElement->getNextElement())
{
if (childElement->getTagName() != "key" || childElement->getNumChildElements() != 1
|| !childElement->getFirstChildElement()->isTextElement())
{
std::cerr << "Invalid first plist content, expected <key> element with only one "
"text child element"
<< std::endl;
return 1;
}
const auto key = childElement->getFirstChildElement()->getText().toStdString();
if (std::find(keysInFirstPlist.begin(), keysInFirstPlist.end(), key)
!= keysInFirstPlist.end())
{
std::cerr << "Invalid first plist content, duplicated key \"" << key << "\""
<< std::endl;
return 1;
}
keysInFirstPlist.push_back(key);
childElement = childElement->getNextElement();
if (childElement == nullptr)
{
std::cerr << "Invalid first plist content, missing value associated with key \""
<< key << "\"" << std::endl;
return 1;
}
}
const juce::ScopedPointer<juce::XmlElement> secondPlistElement =
juce::XmlDocument::parse(args.at(2));
if (!secondPlistElement || !secondPlistElement->hasTagName("plist"))
{
std::cerr << "Invalid second plist content, expected <plist> element" << std::endl;
return 1;
}
const auto secondDictElement = secondPlistElement->getChildByName("dict");
if (!secondDictElement)
{
std::cerr << "Invalid second plist content, expected <dict> element" << std::endl;
return 1;
}
for (auto childElement = secondDictElement->getFirstChildElement();
childElement != nullptr; childElement = childElement->getNextElement())
{
if (childElement->getTagName() != "key" || childElement->getNumChildElements() != 1
|| !childElement->getFirstChildElement()->isTextElement())
{
std::cerr << "Invalid second plist content, expected <key> element with only one "
"text child element"
<< std::endl;
return 1;
}
const auto key = childElement->getFirstChildElement()->getText().toStdString();
const auto isKeyAlreadyInFirstPlist =
std::find(keysInFirstPlist.begin(), keysInFirstPlist.end(), key)
!= keysInFirstPlist.end();
if (!isKeyAlreadyInFirstPlist)
{
firstDictElement->addChildElement(new juce::XmlElement(*childElement));
}
childElement = childElement->getNextElement();
if (childElement == nullptr)
{
std::cerr << "Invalid second plist content, missing value associated with key \""
<< key << "\"" << std::endl;
return 1;
}
if (!isKeyAlreadyInFirstPlist)
{
firstDictElement->addChildElement(new juce::XmlElement(*childElement));
}
}
std::cout << firstPlistElement->createDocument(juce::String{}, false, false)
<< std::flush;
return 0;
}
xptr apply_before_delete_triggers_on_subtree(xptr node, node_triggers_map *fired_triggers)
{
if (tr_globals::internal_auth_switch == BLOCK_AUTH_CHECK) return node;
schema_node_cptr scm_node = getSchemaNode(node);
node_triggers_map attribute_fired_triggers;
node_triggers_map element_fired_triggers;
typedef std::pair< schema_node_xptr, std::vector<trigger_cell_xptr> > mapPair;
std::pair< node_triggers_map::iterator, bool > mapRes;
/*1. Evalute triggers for this node if there are some in fired_triggers map*/
node_triggers_map::iterator mapIter;
trigger_cell_cptr trc = XNULL;
mapIter = fired_triggers->find(scm_node.ptr());
xptr parent=nodeGetParent(node);
if( mapIter != fired_triggers->end())
for(std::vector<trigger_cell_xptr>::size_type i=0; i< mapIter->second.size(); i++)
{
trc = mapIter->second.at(i);
if(trc->execute_trigger_action(XNULL, node, parent) == XNULL) return XNULL;
}
// if the node is attribute - it has no children to process
if (scm_node->type == attribute) return node;
/*2. Find all fired triggers for all the children of the node (attribute_fired_triggers and element_fired_triggers)*/
sc_ref_item* scm_child = scm_node->children->first;
while(scm_child !=NULL)
{
cat_list<trigger_cell_xptr>::item* scm_trc = scm_child->object.snode->trigger_list->first;
if(scm_trc!=NULL)
{
std::vector<trigger_cell_xptr> triggers_vec;
if(scm_child->object.snode->type == attribute)
mapRes = attribute_fired_triggers.insert( mapPair (scm_child->object.snode, triggers_vec) );
else
mapRes = element_fired_triggers.insert( mapPair (scm_child->object.snode, triggers_vec) );
while(scm_trc!=NULL)
{
if((scm_trc->object->trigger_event == TRIGGER_DELETE_EVENT) &&
(scm_trc->object->trigger_granularity == TRIGGER_FOR_EACH_STATEMENT) &&
(scm_trc->object->trigger_time == TRIGGER_BEFORE))
mapRes.first->second.push_back(scm_trc->object);
scm_trc=scm_trc->next;
}
}
scm_child=scm_child->next;
}
/*Call this function on all children recursively*/
xptr attr_child = getFirstAttributeChild(node);
while(attr_child!=XNULL)
{
if(apply_before_delete_triggers_on_subtree(attr_child, &attribute_fired_triggers) ==XNULL)
return XNULL;
attr_child = getNextAttribute(attr_child);
}
xptr elem_child = getFirstElementChild(node);
while(elem_child!=XNULL)
{
if(apply_before_delete_triggers_on_subtree(elem_child, &element_fired_triggers) == XNULL)
return XNULL;
elem_child = getNextElement(elem_child);
}
return node;
}
void HRSstreamStart(HRSstream_t s,
void *filterFunction,
int numSlices,
HRSslice_t slices)
{
assert(s != NULL);
if (s->type == HRS_BINARYSTREAM) {
s->bs->filter = (int (*)(char, void *, char *, char *))filterFunction;
openFirstBinaryFile(s->bs);
}
else if (s->type == HRS_GENERALSTREAM) {
s->gs->filter = (int (*)(char, void *, Sfio_t *, char *))filterFunction;
openFirstGeneralFile(s->gs);
}
else if (s->type == HRS_GENERATIVESTREAM) {
s->gens->filter = (int (*)(char, void *, char *))filterFunction;
}
else if (s->type == HRS_MAPSTREAM) {
s->ms->filter = (int (*)(char, void *, char *, char *))filterFunction;
}
if (numSlices == 0)
/* filter only stream */
s->filterOnly = 1;
else {
int from_pipe[2];
int to_pipe[2];
int keySize;
int recSize;
Sfio_t *tp;
fchandle *fch;
int i;
s->filterOnly = 0;
/* set up fixcut to munge the data */
fch = fcopen();
for (i=0; i < numSlices; i++) {
int bStrSize = numDigits(slices[i].begin);
int eStrSize = numDigits(slices[i].end);
int strSize = bStrSize + 1 + eStrSize +
strlen(slices[i].description) + 1;
char *str = HRSmalloc(strSize, "HRSstreamStart");
sfsprintf(str, strSize, "%d,%d%s", slices[i].begin,
slices[i].end, slices[i].description);
if (fcslice(fch, 'k', str) != 0)
HRSerrorExit1("Fixcut error: %s\n" , fcerror(fch));
/* do we need to/can we free str here? */
}
if ((recSize = fcready(fch, s->logicalSize)) < 0)
HRSerrorExit1("Fixcut error: %s\n" , fcerror(fch));
keySize = recSize - s->logicalSize;
pipe(from_pipe);
pipe(to_pipe);
if (fork() == 0) {
/* child */
extern int HRSpuntExit;
int ac;
char **av;
HRSpuntExit = 1; /* don't do any work on exit in the child */
av = buildSortStr(s, keySize, 0, 1, &ac);
close(to_pipe[1]);
close(from_pipe[0]);
close(0); dup(to_pipe[0]); close(to_pipe[0]);
close(1); dup(from_pipe[1]); close(from_pipe[1]);
amrRSORT(ac, av);
_exit(1);
}
else {
/* parent */
char *logicalData;
uchar *mungedData;
close(to_pipe[0]);
close(from_pipe[1]);
tp = sfnew(NULL, NULL, SF_UNBOUND, to_pipe[1], SF_WRITE | SF_SHARE);
logicalData = HRSmalloc(s->logicalSize, "HRSstreamStart");
while (getNextElement(s, logicalData) != 0) {
int v;
if ((mungedData = fcbuild(fch, (uchar *) logicalData, NULL)) == NULL)
HRSerrorExit1("Fixcut error: %s\n" , fcerror(fch));
v = sfwrite(tp, mungedData, recSize);
if (v == 0)
HRSerrorExit1("stream write to %s failed\n", s->streamName);
}
sfclose(tp);
fcclose(fch);
s->lfp =
sfnew(NULL, NULL, SF_UNBOUND, from_pipe[0], SF_READ | SF_SHARE);
HRSfree(logicalData);
}
}
}
