// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Record *Decimation::next() {
if ( !_source ) {
SEISCOMP_ERROR("[dec] no source defined");
return NULL;
}
while ( true ) {
RecordPtr rec = _source->next();
if ( rec ) {
// If new data has been pushed to stream, return
if ( push(rec.get()) ) {
GenericRecord *rec = _nextRecord;
_nextRecord = NULL;
if ( rec->data()->dataType() != _dataType )
rec->setData(rec->data()->copy(_dataType));
return rec;
}
}
else
break;
}
return NULL;
}
void ReSplit::handle(Input& input, Output& output)
{
RecordPtr rec = input.pop();
for (; !rec->eof(); output.push(rec), rec = input.pop())
{
std::vector<std::size_t>::iterator iter = _columns.begin();
for (; iter != _columns.end(); ++iter)
{
const std::string& col =
static_cast<const std::string&> ((*rec)[*iter]);
boost::smatch parts;
if (_option == Search)
{
boost::regex_search(col, parts, _regex);
}
else
{
boost::regex_match(col, parts, _regex);
}
boost::smatch::iterator iter = parts.begin();
for (; iter != parts.end(); ++iter)
{
if (!iter->matched)
{
continue;
}
rec->insert(rec->end(), std::string(
iter->first, iter->second));
}
}
}
}
std::string Common::getDestination(const RecordPtr& record,
const std::string& source)
{
if (record->getName() == source)
return record->getOnion();
NameList list = record->getSubdomains();
for (auto subdomain : list)
if (subdomain.first + "." + record->getName() == source)
return subdomain.second;
Log::get().error("Record does not contain \"" + source + "\"!");
return "";
}
RecordPtr CommitSession::PopAndUndoRecord()
{
Open();
RecordPtr pRec = m_game.PopRecord();
pRec->Undo(m_game, &m_controller);
m_bUpdateReviewUI |= !pRec->IsMessageRecord();
Output::RemoveLog output(pRec->GetID());
m_controller.SendMessage(output, m_game);
for (auto& g : m_game.GetReviewGames())
m_controller.SendMessage(output, *g);
return pRec;
}
RecordPtr RecordHelper::pythonListToRecord(python::object obj)
{
ssize_t listSize = python::len(obj);
ssize_t i = 0;
RecordPtr ptr = new Record();
ptr->reserve(listSize);
for (; i < listSize; ++i)
{
ptr->insert(ptr->end(), *pythonObjectToAny(obj[i]));
}
return ptr;
}
void Filter::handle(Input& input, Output& output)
{
RecordPtr rec = input.pop();
if (_filterType == FilterAnd)
{
for (; !rec->eof(); rec = input.pop())
{
bool test = true;
std::vector<std::size_t>::iterator iter = _columns.begin();
for (; iter != _columns.end(); ++iter)
{
test = test && (bool) (*rec)[*iter];
if (!test)
{
break;
}
}
if (!test)
{
output.push(rec);
}
}
}
else // _filterType == OpOr
{
bool initial = _columns.begin() == _columns.end();
for (; !rec->eof(); rec = input.pop())
{
bool test = initial;
std::vector<std::size_t>::iterator iter = _columns.begin();
for (; iter != _columns.end(); ++iter)
{
test = test || (bool) (*rec)[*iter];
if (test)
{
break;
}
}
if (!test)
{
output.push(rec);
}
}
}
}
bool Cache::add(const RecordPtr& record)
{ // todo: delete Records should cause deletion/replacement, etc
if (get(record->getName()))
return false; // cannot add record, name is already taken
records_.push_back(record);
return true;
}
python::list RecordHelper::recordToPythonList(RecordPtr rec)
{
if (rec.isNull())
{
return python::list();
}
return vectorToPythonList(*rec);
}
void Select::handle(Input& input, Output& output)
{
RecordPtr rec = input.pop();
for (; !rec->eof(); rec = input.pop())
{
RecordPtr ptr = new Record();
ptr->resize(_columns.size());
std::vector<std::size_t>::iterator iter = _columns.begin();
for (; iter != _columns.end(); ++iter)
{
std::size_t index = iter - _columns.begin();
(*ptr)[index] = (*rec)[*iter];
}
output.push(ptr);
}
}
void CommitSession::DoAndPushRecord(RecordPtr pRec)
{
Open();
pRec->Do(m_game, &m_controller);
m_bUpdateReviewUI |= !pRec->IsMessageRecord();
std::string msg = pRec->GetMessage(m_game);
int id = m_game.PushRecord(std::move(pRec));
ASSERT(!msg.empty());
Output::AddLog output(id, msg);
m_controller.SendMessage(output, m_game);
for (auto& g : m_game.GetReviewGames())
m_controller.SendMessage(output, *g);
}
void Common::checkValidity(const RecordPtr& r)
{
Log::get().notice("Checking validity... ");
bool tmp = false;
r->computeValidity(&tmp);
if (r->hasValidSignature())
Log::get().notice("Record signature is valid.");
else
Log::get().error("Bad signature on Record!");
if (r->isValid()) // todo: this does not actually check the PoW output
Log::get().notice("Record proof-of-work is valid.");
else
Log::get().error("Record is not valid!");
Log::get().notice("Record check complete.");
}
TypePtr recordType(RecordPtr record, const vector<ObjectPtr> ¶ms) {
int h = pointerHash(record.ptr());
vector<ObjectPtr>::const_iterator pi, pend;
for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
h += objectHash(*pi);
h &= recordTypes.size() - 1;
vector<RecordTypePtr>::iterator i, end;
for (i = recordTypes[h].begin(), end = recordTypes[h].end();
i != end; ++i) {
RecordType *t = i->ptr();
if ((t->record == record) && objectVectorEquals(t->params, params))
return t;
}
RecordTypePtr t = new RecordType(record);
for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
t->params.push_back(*pi);
recordTypes[h].push_back(t);
initializeRecordFields(t);
return t.ptr();
}
static inline bool compare_lt(RecordPtr r1, RecordPtr r2) {
return r1->tstamp() < r2->tstamp();
}
static ModulePtr makePrimitivesModule() {
ModulePtr prims = new Module("__primitives__");
addPrim(prims, "Bool", boolType.ptr());
addPrim(prims, "Int8", int8Type.ptr());
addPrim(prims, "Int16", int16Type.ptr());
addPrim(prims, "Int32", int32Type.ptr());
addPrim(prims, "Int64", int64Type.ptr());
addPrim(prims, "Int128", int128Type.ptr());
addPrim(prims, "UInt8", uint8Type.ptr());
addPrim(prims, "UInt16", uint16Type.ptr());
addPrim(prims, "UInt32", uint32Type.ptr());
addPrim(prims, "UInt64", uint64Type.ptr());
addPrim(prims, "UInt128", uint128Type.ptr());
addPrim(prims, "Float32", float32Type.ptr());
addPrim(prims, "Float64", float64Type.ptr());
addPrim(prims, "Float80", float80Type.ptr());
addPrim(prims, "Imag32", imag32Type.ptr());
addPrim(prims, "Imag64", imag64Type.ptr());
addPrim(prims, "Imag80", imag80Type.ptr());
addPrim(prims, "Complex32", complex32Type.ptr());
addPrim(prims, "Complex64", complex64Type.ptr());
addPrim(prims, "Complex80", complex80Type.ptr());
GlobalAliasPtr v =
new GlobalAlias(new Identifier("ExceptionsEnabled?"),
PUBLIC,
vector<PatternVar>(),
NULL,
vector<IdentifierPtr>(),
NULL,
new BoolLiteral(exceptionsEnabled()));
addPrim(prims, "ExceptionsEnabled?", v.ptr());
vector<IdentifierPtr> recordParams;
RecordBodyPtr recordBody = new RecordBody(vector<RecordFieldPtr>());
recordParams.push_back(new Identifier("T"));
RecordPtr byRefRecord = new Record(new Identifier("ByRef"),
PUBLIC,
vector<PatternVar>(),
NULL,
recordParams,
NULL,
recordBody);
byRefRecord->env = new Env(prims);
addPrim(prims, "ByRef", byRefRecord.ptr());
recordParams.clear();
recordParams.push_back(new Identifier("Properties"));
recordParams.push_back(new Identifier("Fields"));
RecordPtr rwpRecord = new Record(new Identifier("RecordWithProperties"),
PUBLIC,
vector<PatternVar>(),
NULL,
recordParams,
NULL,
recordBody);
rwpRecord->env = new Env(prims);
addPrim(prims, "RecordWithProperties", rwpRecord.ptr());
#define PRIMITIVE(x) addPrimOp(prims, toPrimStr(#x), new PrimOp(PRIM_##x))
PRIMITIVE(TypeP);
PRIMITIVE(TypeSize);
PRIMITIVE(TypeAlignment);
PRIMITIVE(StaticCallDefinedP);
PRIMITIVE(StaticCallOutputTypes);
PRIMITIVE(StaticMonoP);
PRIMITIVE(StaticMonoInputTypes);
PRIMITIVE(bitcopy);
PRIMITIVE(bitcast);
PRIMITIVE(boolNot);
PRIMITIVE(integerEqualsP);
PRIMITIVE(integerLesserP);
PRIMITIVE(numericAdd);
PRIMITIVE(numericSubtract);
PRIMITIVE(numericMultiply);
PRIMITIVE(floatDivide);
PRIMITIVE(numericNegate);
PRIMITIVE(integerQuotient);
PRIMITIVE(integerRemainder);
PRIMITIVE(integerShiftLeft);
PRIMITIVE(integerShiftRight);
PRIMITIVE(integerBitwiseAnd);
PRIMITIVE(integerBitwiseOr);
PRIMITIVE(integerBitwiseXor);
PRIMITIVE(integerBitwiseNot);
PRIMITIVE(numericConvert);
PRIMITIVE(integerAddChecked);
PRIMITIVE(integerSubtractChecked);
PRIMITIVE(integerMultiplyChecked);
PRIMITIVE(integerQuotientChecked);
PRIMITIVE(integerRemainderChecked);
PRIMITIVE(integerShiftLeftChecked);
PRIMITIVE(integerNegateChecked);
PRIMITIVE(integerConvertChecked);
PRIMITIVE(floatOrderedEqualsP);
PRIMITIVE(floatOrderedLesserP);
PRIMITIVE(floatOrderedLesserEqualsP);
PRIMITIVE(floatOrderedGreaterP);
PRIMITIVE(floatOrderedGreaterEqualsP);
PRIMITIVE(floatOrderedNotEqualsP);
PRIMITIVE(floatOrderedP);
PRIMITIVE(floatUnorderedEqualsP);
PRIMITIVE(floatUnorderedLesserP);
PRIMITIVE(floatUnorderedLesserEqualsP);
PRIMITIVE(floatUnorderedGreaterP);
PRIMITIVE(floatUnorderedGreaterEqualsP);
PRIMITIVE(floatUnorderedNotEqualsP);
PRIMITIVE(floatUnorderedP);
PRIMITIVE(Pointer);
PRIMITIVE(addressOf);
PRIMITIVE(pointerDereference);
PRIMITIVE(pointerOffset);
PRIMITIVE(pointerToInt);
PRIMITIVE(intToPointer);
PRIMITIVE(nullPointer);
PRIMITIVE(CodePointer);
PRIMITIVE(makeCodePointer);
PRIMITIVE(AttributeStdCall);
PRIMITIVE(AttributeFastCall);
PRIMITIVE(AttributeCCall);
PRIMITIVE(AttributeThisCall);
PRIMITIVE(AttributeLLVMCall);
PRIMITIVE(AttributeDLLImport);
PRIMITIVE(AttributeDLLExport);
PRIMITIVE(ExternalCodePointer);
PRIMITIVE(makeExternalCodePointer);
PRIMITIVE(callExternalCodePointer);
PRIMITIVE(Array);
PRIMITIVE(arrayRef);
PRIMITIVE(arrayElements);
PRIMITIVE(Vec);
PRIMITIVE(Tuple);
PRIMITIVE(TupleElementCount);
PRIMITIVE(tupleRef);
PRIMITIVE(tupleElements);
PRIMITIVE(Union);
PRIMITIVE(UnionMemberCount);
PRIMITIVE(RecordP);
PRIMITIVE(RecordFieldCount);
PRIMITIVE(RecordFieldName);
PRIMITIVE(RecordWithFieldP);
PRIMITIVE(recordFieldRef);
PRIMITIVE(recordFieldRefByName);
PRIMITIVE(recordFields);
PRIMITIVE(VariantP);
PRIMITIVE(VariantMemberIndex);
PRIMITIVE(VariantMemberCount);
PRIMITIVE(VariantMembers);
PRIMITIVE(variantRepr);
PRIMITIVE(Static);
PRIMITIVE(ModuleName);
PRIMITIVE(StaticName);
PRIMITIVE(staticIntegers);
PRIMITIVE(integers);
PRIMITIVE(staticFieldRef);
PRIMITIVE(EnumP);
PRIMITIVE(EnumMemberCount);
PRIMITIVE(EnumMemberName);
PRIMITIVE(enumToInt);
PRIMITIVE(intToEnum);
PRIMITIVE(IdentifierP);
PRIMITIVE(IdentifierSize);
PRIMITIVE(IdentifierConcat);
PRIMITIVE(IdentifierSlice);
PRIMITIVE(IdentifierModuleName);
PRIMITIVE(IdentifierStaticName);
PRIMITIVE(OrderUnordered);
PRIMITIVE(OrderMonotonic);
PRIMITIVE(OrderAcquire);
PRIMITIVE(OrderRelease);
PRIMITIVE(OrderAcqRel);
PRIMITIVE(OrderSeqCst);
PRIMITIVE(FlagP);
PRIMITIVE(Flag);
PRIMITIVE(atomicFence);
PRIMITIVE(atomicRMW);
PRIMITIVE(atomicLoad);
PRIMITIVE(atomicStore);
PRIMITIVE(atomicCompareExchange);
PRIMITIVE(RMWXchg);
PRIMITIVE(RMWAdd);
PRIMITIVE(RMWSubtract);
PRIMITIVE(RMWAnd);
PRIMITIVE(RMWNAnd);
PRIMITIVE(RMWOr);
PRIMITIVE(RMWXor);
PRIMITIVE(RMWMin);
PRIMITIVE(RMWMax);
PRIMITIVE(RMWUMin);
PRIMITIVE(RMWUMax);
PRIMITIVE(activeException);
PRIMITIVE(memcpy);
PRIMITIVE(memmove);
PRIMITIVE(countValues);
PRIMITIVE(nthValue);
PRIMITIVE(withoutNthValue);
PRIMITIVE(takeValues);
PRIMITIVE(dropValues);
PRIMITIVE(LambdaRecordP);
PRIMITIVE(LambdaSymbolP);
PRIMITIVE(LambdaMonoP);
PRIMITIVE(LambdaMonoInputTypes);
PRIMITIVE(GetOverload);
#undef PRIMITIVE
return prims;
}
