text:
// ---------------------------------------------------------------------------- PCH
#include "simulator/runtime/pch/stdpch.h"
// ----------------------------------------------------------------------- INCLUDES
// ----------------------------------------------------------------------- SYNOPSIS
#include "utils/src/debug/static_assert.h"
#include "simulator/runtime/rdo_value.h"
#include "simulator/runtime/rdo_enum.h"
#include "simulator/runtime/rdo_array.h"
#include "simulator/runtime/rdo_matrix.h"
#include "simulator/runtime/rdo_fuzzy.h"
#include "simulator/runtime/rdo_exception.h"
// --------------------------------------------------------------------------------

OPEN_RDO_RUNTIME_NAMESPACE

// --------------------------------------------------------------------------------
// -------------------- RDOValue
// --------------------------------------------------------------------------------
RDOValue::RDOValue()
	: m_pType(g_unknow)
{
	setUndefined(false);
}

RDOValue::RDOValue(const RDOValue& rdovalue)
{
	set(rdovalue);
}

RDOValue::RDOValue(const LPRDOType& pType)
	: m_pType(pType)
{
	switch (typeID())
	{
	case RDOType::t_unknow        : break;
	case RDOType::t_int           : __get<int>   () = 0; break;
	case RDOType::t_real          : __get<double>() = 0; break;
	case RDOType::t_enum          : __get<std::size_t> () = 0; break;
	case RDOType::t_bool          : __get<bool> () = false; break;
	case RDOType::t_string        : new (&m_value) rdo::intrusive_ptr_interface_wrapper<string_class>(new string_class("")); break;
	case RDOType::t_identificator : new (&m_value) rdo::intrusive_ptr_interface_wrapper<string_class>(new string_class("")); break;
	default                       : throw RDOValueException();
	}
	setUndefined(false);
}

RDOValue::RDOValue(int value)
	: m_pType(g_int)
{
	__get<int>() = value;
	setUndefined(false);
}

RDOValue::RDOValue(std::size_t value)
	: m_pType(g_int)
{
        __get<std::size_t>() = value;
	setUndefined(false);
}

RDOValue::RDOValue(double value)
	: m_pType(g_real)
{
	__get<double>() = value;
	setUndefined(false);
}

RDOValue::RDOValue(bool value)
	: m_pType(g_bool)
{
	__get<bool>() = value;
	setUndefined(false);
}

RDOValue::RDOValue(const LPRDOEnumType& pEnum)
	: m_pType(pEnum)
{
	if (pEnum->empty())
		RDOValueException();

	__get<std::size_t>() = pEnum->findEnum(pEnum->getValues()[0]);
	setUndefined(false);
}

RDOValue::RDOValue(const LPRDOEnumType& pEnum, const std::string& value)
	: m_pType(pEnum)
{
	__get<std::size_t>() = pEnum->findEnum(value);
	if (__get<std::size_t>() == RDOEnumType::END)
		RDOValueException();
	setUndefined(false);
}

RDOValue::RDOValue(const LPRDOEnumType& pEnum, std::size_t index)
	: m_pType(pEnum)
{
	if (index == RDOEnumType::END || index >= pEnum->getValues().size())
		RDOValueException();

	__get<std::size_t>() = index;
	setUndefined(false);
}

RDOValue::RDOValue(const std::string& value)
	: m_pType(g_string)
{
	STATIC_ASSERT(sizeof(rdo::intrusive_ptr_interface_wrapper<string_class>) >= sizeof(double));

	new (&m_value) rdo::intrusive_ptr_interface_wrapper<string_class>(new string_class(value));
	setUndefined(false);
}

RDOValue::RDOValue(const char* value)
	: m_pType(g_string)
{
	new (&m_value) rdo::intrusive_ptr_interface_wrapper<string_class>(new string_class(value));
	setUndefined(false);
}

RDOValue::RDOValue(const std::string& value, const LPRDOType& pType)
	: m_pType(g_identificator)
{
	if (pType->typeID() != RDOType::t_identificator)
		RDOValueException();

	new (&m_value) rdo::intrusive_ptr_interface_wrapper<string_class>(new string_class(value));
	setUndefined(false);
}

RDOValue::~RDOValue()
{
	deleteValue();
}

RDOValue RDOValue::fromDouble(const LPRDOType& pType, double value)
{
	RDOValue result(pType);

	switch (result.typeID())
	{
	case RDOType::t_unknow: break;
	case RDOType::t_int   : result.__get<int>   () = int(value); break;
	case RDOType::t_real  : result.__get<double>() = value; break;
	case RDOType::t_enum  : result.__get<std::size_t> () = std::size_t(value); break;
	case RDOType::t_bool  : result.__get<bool> () = value != 0.0; break;
	default               : throw RDOValueException();
	}
	result.setUndefined(false);

	return result;
}

void RDOValue::deleteValue()
{
	switch (typeID())
	{
	case RDOType::t_string       :
	case RDOType::t_identificator:
	case RDOType::t_pointer      :
		reinterpret_cast<rdo::LPIRefCounter>(&m_value)->release();
		break;
	default:
		break;
	}
}

const LPRDOType& RDOValue::type() const
{
	return m_pType;
}

RDOType::TypeID RDOValue::typeID() const
{
	return m_pType->typeID();
}

std::ostream& operator<< (std::ostream& stream, const RDOValue& rdovalue)
{
	stream << rdovalue.getAsStringForTrace();
	return stream;
}

int RDOValue::getInt() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int    : return __get<int>();
	case RDOType::t_real   : return (int)__get<double>();
	case RDOType::t_enum   : return __get<std::size_t>();
	case RDOType::t_bool   : return __get<bool>() ? 1 : 0;
	case RDOType::t_pointer: return onPointerGetInt();
	default                : break;
	}
	throw RDOValueException();
}

uint32_t RDOValue::getUInt() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int    : return __get<uint32_t>();
	case RDOType::t_real   : return (uint32_t)__get<double>();
	case RDOType::t_enum   : return __get<std::size_t>();
	case RDOType::t_bool   : return __get<bool>() ? 1 : 0;
	case RDOType::t_pointer: return onPointerGetUInt();
	default                : break;
	}
	throw RDOValueException();
}

int RDOValue::getEnumAsInt() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int : return __get<int>();
	case RDOType::t_real: return (int)__get<double>();
	case RDOType::t_enum: return __get<std::size_t>();
	case RDOType::t_bool: return __get<bool>() ? 1 : 0;
	default             : break;
	}
	throw RDOValueException();
}

LPRDOEnumType RDOValue::getEnum() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_enum: return __enumT();
	default             : break;
	}
	throw RDOValueException();
}

double RDOValue::getDouble() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int : return __get<int>();
	case RDOType::t_real: return __get<double>();
	case RDOType::t_enum: return __get<std::size_t>();
	case RDOType::t_bool: return __get<bool>() ? 1 : 0;
	default             : break;
	}
	throw RDOValueException();
}

bool RDOValue::getBool() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_bool: return __get<bool>();
	default             : break;
	}
	throw RDOValueException();
}

bool RDOValue::getAsBool() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int   : return __get<int>() ? true : false;
	case RDOType::t_real  : return __get<double>() ? true : false;
	case RDOType::t_enum  : return __get<std::size_t>() ? true : false;
	case RDOType::t_string: return !__stringV().empty() ? true : false;
	case RDOType::t_bool  : return __get<bool> ();
	default               : break;
	}
	throw RDOValueException();
}

const std::string& RDOValue::getString() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_string: return __stringV();
	default               : break;
	}
	throw RDOValueException();
}

const std::string& RDOValue::getIdentificator() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_identificator: return __stringV();
	default                      : break;
	}
	throw RDOValueException();
}

std::string RDOValue::getAsString() const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int          : return rdo::format("%d", __get<int>());
	case RDOType::t_real         : return rdo::toString(__get<double>());
	case RDOType::t_enum         : return __enumT()->getValues().at(__get<std::size_t>());
	case RDOType::t_bool         : return __get<bool>() ? "true" : "false";
	case RDOType::t_string       : return __stringV();
	case RDOType::t_identificator: return __stringV();
	case RDOType::t_pointer      : return onPointerAsString();
	default                      : break;
	}
	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод getAsString()");
}

std::string RDOValue::getAsStringForTrace() const
{
	if (isUndefined())
		return "#";

	switch (typeID())
	{
	case RDOType::t_int    : return rdo::format("%d", __get<int>());
	case RDOType::t_real   : return rdo::toString(__get<double>());
	case RDOType::t_enum   : return rdo::format("%d", __get<std::size_t>());
	case RDOType::t_bool   : return __get<bool>() ? "true" : "false";
	case RDOType::t_string : return __stringV();
	case RDOType::t_pointer: return onPointerAsString();
	default                : break;
	}
	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод getAsStringForTrace()");
}

void RDOValue::set(const RDOValue& rdovalue)
{
	m_pType     = rdovalue.m_pType;
	m_undefined = rdovalue.m_undefined;
	switch (typeID())
	{
	case RDOType::t_string       :
	case RDOType::t_identificator:
	case RDOType::t_pointer      :
		{
			memcpy(&m_value, &rdovalue.m_value, sizeof(m_value));
			reinterpret_cast<rdo::LPIRefCounter>(&m_value)->addref();
			break;
		}
	default:
		{
			memcpy(&m_value, &rdovalue.m_value, sizeof(m_value));
			break;
		}
	}
}

RDOValue& RDOValue::operator= (const RDOValue& rdovalue)
{
	deleteValue();
	set(rdovalue);
	return *this;
}

bool RDOValue::operator== (const RDOValue& rdovalue) const
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int : return __get<int>() == rdovalue.__get<int>();
			case RDOType::t_real: return __get<int>() == rdovalue.__get<double>();
			default             : break;
			}
			break;
		}
	case RDOType::t_real:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int : return __get<double>()  == rdovalue.__get<int>();
			case RDOType::t_real: return __get<double>()  == rdovalue.__get<double>();
			default             : break;
			}
			break;
		}
	case RDOType::t_bool:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_bool: return __get<bool>() == rdovalue.__get<bool>();
			default             : break;
			}
			break;
		}
	case RDOType::t_enum:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_enum: if (m_pType == rdovalue.m_pType) return __get<std::size_t>() == rdovalue.__get<std::size_t>(); break;
			default             : break;
			}
			break;
		}
	case RDOType::t_string:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_string: return __stringV() == rdovalue.__stringV();
			default               : break;
			}
			break;
		}
	case RDOType::t_identificator:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_identificator: return __stringV() == rdovalue.__stringV();
			default                      : break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerEqual(rdovalue);
		}
	default:
		break;
	}
	throw RDOValueException();
}

bool RDOValue::operator!= (const RDOValue& rdovalue) const
{
	return !operator==(rdovalue);
}

bool RDOValue::operator< (const RDOValue& rdovalue) const
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int : return __get<int>() < rdovalue.__get<int>();
			case RDOType::t_real: return __get<int>() < rdovalue.__get<double>();
			default             : break;
			}
			break;
		}
	case RDOType::t_real:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int : return __get<double>() < rdovalue.__get<int>();
			case RDOType::t_real: return __get<double>() < rdovalue.__get<double>();
			default             : break;
			}
			break;
		}
	case RDOType::t_bool:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_bool: return __get<bool>() < rdovalue.__get<bool>();
			default             : break;
			}
			break;
		}
	case RDOType::t_string:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_string: return __stringV() < rdovalue.__stringV();
			default               : break;
			}
			break;
		}
	default:
		break;
	}
	throw RDOValueException();
}

bool RDOValue::operator> (const RDOValue& rdovalue) const
{
	return !operator<=(rdovalue);
}

bool RDOValue::operator<= (const RDOValue& rdovalue) const
{
	return operator<(rdovalue) || operator==(rdovalue);
}

bool RDOValue::operator>= (const RDOValue& rdovalue) const
{
	return operator>(rdovalue) || operator==(rdovalue);
}

RDOValue RDOValue::operator&& (const RDOValue& rdovalue) const
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_bool:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_bool: return __get<bool>() && rdovalue.__get<bool>();
			default             : break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerAnd(rdovalue);
		}
	default:
		break;
	}
	throw RDOValueException();
}

RDOValue RDOValue::operator|| (const RDOValue& rdovalue) const
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_bool:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_bool: return __get<bool>() || rdovalue.__get<bool>();
			default             : break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerAnd(rdovalue);
		}
	default:
		break;
	}
	throw RDOValueException();
}

RDOValue RDOValue::operator- () const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int    : return RDOValue(-__get<int>   ());
	case RDOType::t_real   : return RDOValue(-__get<double>());
	case RDOType::t_bool   : return RDOValue(!__get<bool> ());
	case RDOType::t_pointer: return onPointerUMinus();
	default                : throw RDOValueException();
	}
}

bool RDOValue::operator! () const
{
	if (isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int : return !__get<int>   (); break;
	case RDOType::t_real: return !__get<double>(); break;
	case RDOType::t_bool: return !__get<bool> (); break;
	default             : throw RDOValueException();
	}
}

RDOValue& RDOValue::operator+= (const RDOValue& rdovalue)
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<int>() += rdovalue.getInt(); return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_real:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<double>() += rdovalue.getDouble(); return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_string:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_string:
				{
					rdo::LPIRefCounter pIRefCountrer = reinterpret_cast<rdo::LPIRefCounter>(&m_value);
					ASSERT(pIRefCountrer);

					if (!pIRefCountrer->owner())
					{
						pIRefCountrer->release();
						new (&m_value) rdo::intrusive_ptr_interface_wrapper<string_class>(new string_class(__stringV()));
					}

					__stringV() += rdovalue.__stringV();
					return *this;
				}
			default: break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerPlus(rdovalue);
		}
	default:
		break;
	}

	throw RDOValueException();
}

const RDOValue& RDOValue::operator++()
{
	operator+=(1);
	return *this;
}

RDOValue RDOValue::operator++(int /*inc*/)
{
	if (isUndefined())
		throw RDOUndefinedException();

	RDOValue prevValue(typeID() == RDOType::t_pointer ? clone() : *this);
	operator+=(1);
	return prevValue;
}

const RDOValue& RDOValue::operator--()
{
	if (isUndefined())
		throw RDOUndefinedException();

	operator-=(1);
	return *this;
}

RDOValue RDOValue::operator--(int /*inc*/)
{
	if (isUndefined())
		throw RDOUndefinedException();

	RDOValue prevValue(typeID() == RDOType::t_pointer ? clone() : *this);
	operator-=(1);
	return prevValue;
}

RDOValue& RDOValue::operator-= (const RDOValue& rdovalue)
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<int>() -= rdovalue.getInt(); return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_real:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<double>() -= rdovalue.getDouble(); return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerMinus(rdovalue);
		}
	default:
		break;
	}

	throw RDOValueException();
}

RDOValue& RDOValue::operator*= (const RDOValue& rdovalue)
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int : __get<int>() *= rdovalue.__get<int>(); return *this;
			case RDOType::t_real: __get<double>() = ((double)__get<int>()) * rdovalue.__get<double>(); m_pType = g_real; return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_real:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<double>() *= rdovalue.getDouble(); return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerMult(rdovalue);
		}
	default:
		break;
	}

	throw RDOValueException();
}

RDOValue& RDOValue::operator/= (const RDOValue& rdovalue)
{
	if (isUndefined() || rdovalue.isUndefined())
		throw RDOUndefinedException();

	switch (typeID())
	{
	case RDOType::t_int:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<double>() = ((double)__get<int>()) / rdovalue.getDouble(); m_pType = g_real; return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_real:
		{
			switch (rdovalue.typeID())
			{
			case RDOType::t_int :
			case RDOType::t_real: __get<double>() = __get<double>() / rdovalue.getDouble(); return *this;
			default             : break;
			}
			break;
		}
	case RDOType::t_pointer:
		{
			return onPointerDiv(rdovalue);
		}
	default:
		break;
	}

	throw RDOValueException();
}

RDOValue RDOValue::operator+ (const RDOValue& rdovalue) const
{
	RDOValue value2(*this);
	value2 += rdovalue;
	return value2;
}

RDOValue RDOValue::operator- (const RDOValue& rdovalue) const
{
	RDOValue value2(*this);
	value2 -= rdovalue;
	return value2;
}

RDOValue RDOValue::operator* (const RDOValue& rdovalue) const
{
	RDOValue value2(*this);
	value2 *= rdovalue;
	return value2;
}

RDOValue RDOValue::operator/ (const RDOValue& rdovalue) const
{
	RDOValue value2(*this);
	value2 /= rdovalue;
	return value2;
}

//RDOValue RDOValue::operator[] (const RDOValue& rdovalue)
//{
//	switch (typeID())
//	{
//	case RDOType::t_array : return __arrayV ()->operator [](rdovalue);
//	case RDOType::t_matrix: return __matrixV()[rdovalue];
//	}
//	throw RDOValueException();
//}
//
//RDOValue RDOValue::begin()
//{
//	switch (typeID())
//	{
//	case RDOType::t_array : return RDOValue(rdo::Factory<RDOArrayIterator>::create(__arrayV()->containerBegin()));
//	case RDOType::t_matrix: return RDOValue(RDOMatrixIterator(__matrixV().containerBegin()));
//	}
//	throw RDOValueException();
//}
//
//RDOValue RDOValue::end()
//{
//	switch (typeID())
//	{
//	case RDOType::t_array : return RDOValue(rdo::Factory<RDOArrayIterator>::create( __arrayV()->containerEnd()));
//	case RDOType::t_matrix: return RDOValue(RDOMatrixIterator(__matrixV().containerEnd()));
//	}
//	throw RDOValueException();
//}
//
//void RDOValue::insert(const RDOValue& itr, const RDOValue& itrFst, const RDOValue& itrLst)
//{
//	switch (typeID())
//	{
//	case RDOType::t_array : __arrayV ()->insertItems(itr.__arrayItr()->getIterator(), itrFst.__arrayItr ()->getIterator(), itrLst.__arrayItr ()->getIterator()); return;
//	case RDOType::t_matrix: __matrixV().insertItems(itr.__matrixItr().getIterator(), itrFst.__matrixItr().getIterator(), itrLst.__matrixItr().getIterator()); return;
//	}
//	throw RDOValueException();
//}
//
//void RDOValue::erase(const RDOValue& itrFst, const RDOValue& itrLst)
//{
//	switch (typeID())
//	{
//	case RDOType::t_array : __arrayV ()->eraseItems(itrFst.__arrayItr ()->getIterator(), itrLst.__arrayItr ()->getIterator()); return;
//	case RDOType::t_matrix: __matrixV().eraseItems(itrFst.__matrixItr().getIterator(), itrLst.__matrixItr().getIterator()); return;
//	}
//	throw RDOValueException();
//}
//
//void RDOValue::setArrayItem(const RDOValue& ind, const RDOValue& item)
//{
//	switch (typeID())
//	{
//	case RDOType::t_array :
//		{
//			__arrayV()->setArrayItem(ind, item);
//			return;
//		}
//	}
//	throw RDOValueException();
//}

void*& RDOValue::__voidPtrV()
{
	return __get<void*>();
}

const void*& RDOValue::__voidPtrV() const
{
	return *reinterpret_cast<const void**>(&const_cast<RDOValue*>(this)->m_value);
}

LPRDOEnumType RDOValue::__enumT() const
{
	return m_pType.object_static_cast<RDOEnumType>();
}

std::string& RDOValue::__stringV()
{
	return *getPointer<string_class>().get();
}

const std::string& RDOValue::__stringV() const
{
	return *getPointer<string_class>().get();
}

RDOValue RDOValue::clone() const
{
	bool undefined = isUndefined();
	const_cast<RDOValue*>(this)->setUndefined(false);

	RDOValue result;
	switch (typeID())
	{
	case RDOType::t_int          : result = RDOValue(getInt()); break;
	case RDOType::t_real         : result = RDOValue(getDouble()); break;
	case RDOType::t_enum         : result = RDOValue(getEnum(), getEnumAsInt()); break;
	case RDOType::t_bool         : result = RDOValue(getBool()); break;
	case RDOType::t_string       : result = RDOValue(getString()); break;
	case RDOType::t_identificator: result = RDOValue(getIdentificator(), g_identificator); break;
	case RDOType::t_pointer      :
		{
			LPRDOArrayType pThisArrayType = m_pType.object_dynamic_cast<RDOArrayType>();
			if (pThisArrayType)
			{
				LPRDOArrayValue pValue = getPointer<RDOArrayValue>();
				ASSERT(pValue);
				result = RDOValue(pThisArrayType, pValue->clone());
				break;
			}

			LPRDOArrayIterator pThisArrayIterator = m_pType.object_dynamic_cast<RDOArrayIterator>();
			if (pThisArrayIterator)
			{
				LPRDOArrayIterator pIterator = pThisArrayIterator->clone();
				ASSERT(pIterator);
				result = RDOValue(pIterator, pIterator);
				break;
			}

			LPRDOMatrixIterator pThisMatrixIterator = m_pType.object_dynamic_cast<RDOMatrixIterator>();
			if (pThisMatrixIterator)
			{
				LPRDOMatrixIterator pIterator = pThisMatrixIterator->clone();
				ASSERT(pIterator);
				result = RDOValue(pIterator, pIterator);
				break;
			}
		}
		break;
	default: break;
	}

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPFuzzySet pCloneValue = pThisValue->clone();
	//	ASSERT(pCloneValue);

	//	return RDOValue(pCloneValue->type(), pCloneValue);
	//}

	if (result.typeID() == RDOType::t_unknow)
	{
		throw RDOValueException("Для rdo::runtime::RDOValue не определен метод clone()");
	}
	result.setUndefined(undefined);
	const_cast<RDOValue*>(this)->setUndefined(undefined);
	return result;
}

std::string RDOValue::onPointerAsString() const
{
	ASSERT(typeID() == RDOType::t_pointer);

	LPRDOArrayType pThisArrayType = m_pType.object_dynamic_cast<RDOArrayType>();
	if (pThisArrayType)
	{
		LPRDOArrayValue pValue = getPointer<RDOArrayValue>();
		ASSERT(pValue);
		return pValue->getAsString();
	}

	LPRDOArrayIterator pThisArrayIterator = m_pType.object_dynamic_cast<RDOArrayIterator>();
	if (pThisArrayIterator)
	{
		return pThisArrayIterator->getValue().getAsString();
	}

	LPRDOMatrixType pThisMatrixType = m_pType.object_dynamic_cast<RDOMatrixType>();
	if (pThisMatrixType)
	{
		LPRDOMatrixValue pValue = getPointer<RDOMatrixValue>();
		ASSERT(pValue);
		return pValue->getAsString();
	}

	LPRDOMatrixIterator pThisMatrixIterator = m_pType.object_dynamic_cast<RDOMatrixIterator>();
	if (pThisMatrixIterator)
	{
		return pThisMatrixIterator->getValue().getAsString();
	}

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pValue = getPointer<FuzzySet>();
	//	ASSERT(pValue);
	//	return pValue->getAsString();
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод getAsString()");
}

bool RDOValue::onPointerEqual(const RDOValue& rdovalue) const
{
	ASSERT(typeID() == RDOType::t_pointer);

	LPRDOArrayIterator pThisArrayIterator = m_pType.object_dynamic_cast<RDOArrayIterator>();
	if (pThisArrayIterator)
	{
		LPRDOArrayIterator pValueArrayIterator = rdovalue.type().object_dynamic_cast<RDOArrayIterator>();
		if (pValueArrayIterator)
		{
			return pThisArrayIterator->equal(pValueArrayIterator);
		}
	}

	LPRDOMatrixIterator pThisMatrixIterator = m_pType.object_dynamic_cast<RDOMatrixIterator>();
	if (pThisMatrixIterator)
	{
		LPRDOMatrixIterator pValueMatrixIterator = rdovalue.type().object_dynamic_cast<RDOMatrixIterator>();
		if (pValueMatrixIterator)
		{
			return pThisMatrixIterator->equal(pValueMatrixIterator);
		}
	}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerEqual()");
}

RDOValue& RDOValue::onPointerPlus(const RDOValue& rdovalue)
{
	ASSERT(typeID() == RDOType::t_pointer);

	LPRDOArrayIterator pThisArrayIterator = m_pType.object_dynamic_cast<RDOArrayIterator>();
	if (pThisArrayIterator)
	{
		if (rdovalue.typeID() == RDOType::t_int)
		{
			pThisArrayIterator->preInc(rdovalue.getInt());
			return *this;
		}
	}

	LPRDOMatrixIterator pThisMatrixIterator = m_pType.object_dynamic_cast<RDOMatrixIterator>();
	if (pThisMatrixIterator)
	{
		if (rdovalue.typeID() == RDOType::t_int)
		{
			pThisMatrixIterator->preInc(rdovalue.getInt());
			return *this;
		}
	}

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPRDOFuzzyType pValueFuzzyType = rdovalue.type().object_dynamic_cast<RDOFuzzyType>();
	//	if (pValueFuzzyType)
	//	{
	//		pThisValue->operator+ (rdovalue.getPointer<FuzzySet>());
	//		return *this;
	//	}
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerPlus()");
}

RDOValue& RDOValue::onPointerMinus(const RDOValue& rdovalue)
{
	ASSERT(typeID() == RDOType::t_pointer);

	LPRDOArrayIterator pThisArrayIterator = m_pType.object_dynamic_cast<RDOArrayIterator>();
	if (pThisArrayIterator)
	{
		if (rdovalue.typeID() == RDOType::t_int)
		{
			pThisArrayIterator->preInc(-rdovalue.getInt());
			return *this;
		}
	}

	LPRDOMatrixIterator pThisMatrixIterator = m_pType.object_dynamic_cast<RDOMatrixIterator>();
	if (pThisMatrixIterator)
	{
		if (rdovalue.typeID() == RDOType::t_int)
		{
			pThisMatrixIterator->preInc(-rdovalue.getInt());
			return *this;
		}
	}

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPRDOFuzzyType pValueFuzzyType = rdovalue.type().object_dynamic_cast<RDOFuzzyType>();
	//	if (pValueFuzzyType)
	//	{
	//		pThisValue->operator -(rdovalue.getPointer<FuzzySet>());
	//		return *this;
	//	}
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerMinus()");
}

RDOValue& RDOValue::onPointerMult(const RDOValue& /*rdovalue*/)
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPRDOFuzzyType pValueFuzzyType = rdovalue.type().object_dynamic_cast<RDOFuzzyType>();
	//	if (pValueFuzzyType)
	//	{
	//		pThisValue->operator*(rdovalue.getPointer<FuzzySet>());
	//		return *this;
	//	}
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerMult()");
}

RDOValue& RDOValue::onPointerDiv(const RDOValue& /*rdovalue*/)
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPRDOFuzzyType pValueFuzzyType = rdovalue.type().object_dynamic_cast<RDOFuzzyType>();
	//	if (pValueFuzzyType)
	//	{
	//		pThisValue->operator/(rdovalue.getPointer<FuzzySet>());
	//		return *this;
	//	}
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerMult()");
}

int RDOValue::onPointerGetInt() const
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);
	//	return MemberFunctionProperties::defuzzyfication(pThisValue).getInt();
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerGetInt()");
}

uint32_t RDOValue::onPointerGetUInt() const
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);
	//	return (uint32_t)MemberFunctionProperties::defuzzyfication(pThisValue).getInt();
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerGetUInt()");
}

bool RDOValue::onPointerAnd(const RDOValue& /*rdovalue*/) const
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPRDOFuzzyType pValueFuzzyType = rdovalue.type().object_dynamic_cast<RDOFuzzyType>();
	//	if (pValueFuzzyType)
	//	{
	//		return pThisValue->operator&&(rdovalue.getPointer<FuzzySet>());
	//	}
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerAnd()");
}

bool RDOValue::onPointerOr(const RDOValue& /*rdovalue*/) const
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pThisValue = getPointer<FuzzySet>();
	//	ASSERT(pThisValue);

	//	LPRDOFuzzyType pValueFuzzyType = rdovalue.type().object_dynamic_cast<RDOFuzzyType>();
	//	if (pValueFuzzyType)
	//	{
	//		return pThisValue->operator||(rdovalue.getPointer<FuzzySet>());
	//	}
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerOr()");
}

RDOValue RDOValue::onPointerUMinus() const
{
	ASSERT(typeID() == RDOType::t_pointer);

	//LPRDOFuzzyType pThisFuzzyType = m_pType.object_dynamic_cast<RDOFuzzyType>();
	//if (pThisFuzzyType)
	//{
	//	LPFuzzySet pCloneValue = clone().getPointer<FuzzySet>();
	//	ASSERT(pCloneValue);
	//	return RDOValue(pCloneValue->type(), MemberFunctionProperties::u_minus(pCloneValue));
	//}

	throw RDOValueException("Для rdo::runtime::RDOValue не определен метод onPointerUMinus()");
}

void RDOValue::setUndefined(bool undefined)
{
	m_undefined = undefined;
}

bool RDOValue::isUndefined() const
{
	return m_undefined;
}

// --------------------------------------------------------------------------------
// -------------------- RDOValue::string_class
// --------------------------------------------------------------------------------
RDOValue::string_class::string_class(const std::string& string)
	: std::string(string)
{}

rdo::intrusive_ptr<RDOValue::string_class> RDOValue::string_class::clone() const
{
	return rdo::intrusive_ptr<string_class>(new string_class(c_str()));
}

CLOSE_RDO_RUNTIME_NAMESPACE

redpajama_set_name: RedPajamaGithub


Snowden at SXSW said last week that it's up to the vendors to encrypt customer data. I think he was talking mostly about data-in-flight but there's just a big an exposure for data-at-rest, maybe more so because then, all the data is available, at one sitting.
A couple of weeks ago there was a TechCrunch article (see Apple Explains Exactly How Secure iMessage Really Is or see the Apple IOS Security document) about Apple's iMessage security.
The documents said that Apple iMessage uses public key encryption where every IOS/OS X device generates a pair of public and private keys (one for messages and one for signing) which are used to encrypt the data while it is transmitted through Apple's iMessage service. Apple encrypts the data on its iMessage App running in the devices with every destination device's public key before it's saved on the iMessage server cloud, which can then be decrypted on the device with its private key whenever the message is received by the device.
It's a bit more complex for longer messages and attachments but the gist is that this data is encrypted with a random key at the device and is saved in encrypted form while residing iMessage servers. This random key and URI is then encrypted with the destination devices public keys which is then stored on the iMessage servers. Once the destination device retrieves the message with an attachment it has the location and the random key to decrypt the attachment.
According to Apple's documentation when you start an iMessage you identify the recipient, the app retrieves the public keys for all these devices and then it encrypts the message (with each destination device's public message key) and signs the message (with the originating device's private signing key). This way Apple servers never see the plain text message and never holds the decryption keys.
As mentioned in prior posts, I am now a Dropbox user and utilize this service to synch various IOS and OSX device file data. Which means a copy of all this synch data is sitting on Dropbox (AWS S3) servers, someplace (possibly multiple places) in the cloud.
Dropbox data-at-rest security is explained in their How secure is Dropbox document. Essentially they use SSL for data-in-flight security and AES-256 encryption with a random key for data-at-rest security.
This probably makes it easier to support multiple devices and perhaps data sharing because they only need to encrypt/save the data once and can decrypt the data on its servers before sending it through (SSL encrypted, of course) to other devices.
As far as I know from a data-at-rest security perspective Box looks about the same, so does EMC's Syncplicity, Oxygen Cloud, and probably all the others. There are some subtle differences about how and where the keys are kept and how many security domains exist in each service, but in the end, the service holds the keys to all data that is encrypted on their storage cloud.
That would further delay the transfer of new and updated data to the synch service, also further delaying its availability at other devices linked to the login.
That would cause the storage requirement for your sync&share data to be multiplied by the number of devices you wish to synch with.
If we just take on the synch side of the discussion first maybe it would be easiest. For example, if a new public and private key pair for encryption and signing were to be assigned to each new device at login to the service then the service could retain a directory of the device's public keys for data encryption and signing.
The first device to login to a synch service with a new user-id, would assign a single encryption key for all data to be shared by all devices that could use this login. As other devices log into the service, the prime device sends the single service encryption key encrypted using the target device's public key and signing the message with the source device's private key. Actually any device in the service ring could do this but the primary device could be used to authenticate the new devices login credentials. Each device's synch service would have a list of all the public keys for all the devices in the "synch" region.
As data is created or updated there are two segments of each file that are created, the AES-256 encrypted data package using the "synch" region's random encryption key and the signature package, signed by the device doing the creation/update of the file. Any device could authenticate the signature package at the time it receives a file, as could the service. But ONLY the devices with the AES-256 encryption key would have access to the plain text version of the data.
There are some potential holes in this process, first is that the service could still intercept the random encryption key, at the primary device when it's created or could retrieve it anytime later at its leisure using the app running in the device. This same exposure exists for the iMessage App running in IOS/OS X devices, the private keys in this instance could be sent to another party at any time. We would need to depend on service guarantees to not do this.
For Apple's iMessage attachment security the data is kept in the cloud encrypted by a random key but the key and the URI are sent to the devices when they receive the original message. I suppose this could just as easily work for a file share service but the sharing activity might require a share service app running in the target device to create public-private key pairs and access the file.
Yes this leaves any "shared" data keys being held by the service but it can't be helped. The data is being shared with others so maybe having it be a little more accessible to prying eyes would be acceptable.
I still prefer the iMessage approach, having multiple copies of encrypted shared data, that is encrypted by each device's public key. It's simpler this way, a bit more verifiable and doesn't need to have as much out-of-channel communication (to send keys to other devices).
Yes it would cost more to store any amount of data and would take longer to transmit, but I feel we would all would be willing to support this extra constraints as long as the service guaranteed that private keys were only kept on devices that have logged into the service.
Good article Ray. I think where I'm left feeling dissatisfied is that ultimately we would have to rely on the "good faith" of the provider not to allow the private keys to be stored anywhere else but on the end-user devices. If Snowden's revelations have taught us anything, it's that when sufficiently pressured, technology providers (telcos included obviously) will bend to the demands of intelligence agencies. For this reason alone, it would seem to me the only real solution would be encryption technology that was fully controlled by the end user, regardless of the cloud storage provider.


Highlights: Feasting on a delicious Indian breakfast with many exotic fruits, visiting the ancient Jain Temples in Rankpur to learn about Jainism, winding up and down a beautiful mountain road through the pastoral countryside on our way to Udaipur.
The lovely heritage hotels we stay in always encompass the best best of Indian Architecture & always serve the most delicious & authentic Indian breakfasts. Many heritage properties in India are mansion-turned boutique hotels that still showcase the traditional furniture, art, and architecture of numerous time periods through history. Each property can be up to 600 years old, restored to perfectly encompass the history, yet provide the necessary comfort for even the most luxurious travelers and offering a very traditional sleeping experience. Exotic fruits such as guava, sweet papaya, and sapota line the buffet tables in the morning. On the tables is also a variety of delicious sweet breads, lightly spiced curries, and fluffy eggs – cooked to perfection.
The journey from Jodhpur to Udaipur was peaceful. We drove across beautiful mountain roads filled with pasturelands where shepherds were tending their sheep, we passed by small villages busy with women in colorful saris walking with their purchases from the market, and we stopped in at the beautiful Jain temple complexes that make this part of Southern Rajasthan so mystical.
Rankpur is one of the top pilgrimage sites for Jain people in India. Jainism is very similar to buddhism, as those who practice the religion believe in complete non-violence towards humans and self-control to reach liberation. Today we had the opportunity to visit Rankpur and explore some of the most beautiful & ancient Jain temples in India. The stone work, marble columns, and perfect symmetry of the temple construction was stunning. As we walked through the peaceful abode of the temples, you could almost hear the building sing, as the breeze from outside flowed in and out of the columns.


text:
PIONEERS IN SCIENCE GLADSTONE: Professor Adele Green
For the first time in Gladstone, Pioneers in Science will provide high school students the rare opportunity to interview a renowned scientist live on stage.
Meet Adele Green, Senior Scientist at QIMR Berghofer Medical Research Institute. Professor Green studies one of Australia's most pressing and widespread health issues: skin cancer. Her landmark 20-year study into the regular use of sunscreen proved its effectiveness as an early intervention to decrease melanoma – a breakthrough in cancer research.
In this conversation-style event, ABC Capricornia's Jacquie Mackay will invite pre-selected students from the audience to ask their own questions of Professor Green live on stage.
Following Pioneers in Science, students will explore the interactive science extravaganza that is STREET SCIENCE! Featuring hands-on activities, interactive exhibits and mind-bending experiments, students will taste the pure fun of science.
Students are invited to submit their questions to our pioneer, of which some will be selected for the live show. To submit your questions, please fill out the online form before Wednesday 20 February. Submissions are open now. You will be contacted via email if your question is chosen for the event.
Pioneers in Science 12.30pm – 1.30pm, followed by Street Science 1.30pm – 2.45pm
Complete the QTIX School Group Booking Request form.
If you have any questions, please phone a QTIX Groups Bookings Officer on (07) 3840 7466.
This event is proudly supported by Community Partner Shell's QGC business.
Adele Green
Adèle Green is a Senior Scientist and heads the Cancer and Population Studies Group at the QIMR Berghofer Institute of Medical Research. She trained in medicine, and her research career...
Jacqueline Mackay
After finishing an Honours degree in History and post-graduate qualifications, Jacquie discovered a love of radio work while doing voluntary shifts for the print-handicapped radio station in Perth. This led...
School Years 7 to 12
135mins 12:30pm
Other events you might like
COOL JOBS: Gladstone 2018
The festival's ever-popular Cool Jobs returns to Gladstone! Come face-to-face with amazing scientists doing amazing jobs, and see how they carved their path to an exciting career in STEM. From...

redpajama_set_name: RedPajamaCommonCrawl


Made with Hammered Brass and Sodalite / Black Onyx stones.
Sodalite is superb for enhancing the rational and logical mind. Sodalite is great to work with if your life is chaotic and you are in need of getting your thoughts in order. This stone brings to attention structure from the unconscious, aiding in intuitive forward movement of your life.
Sodalite helps keep emotions and thoughts under control, and allows them to be guides rather than letting them rule your life. Sodalite is also a fantastic stone for soothing anxiety and panic attacks.
A clearer of one's vision, Sodalite opens the mind to formulate wisdom. It dispels mental confusion, and brings self into a state of honest evaluation and awareness. Sodalite also aids in maintaining a calm stable energy. It is a great stone for dream recall.
During PMS Sodalite may be used to balance the emotions—as it works to promote an inner understanding.
Sodalite stimulates deep thought, and is the perfect ally for writers and artists.
Sodalite allows for the shadow self to be seen without judgement. It welcomes self-acceptance to radiate one's being, as well as self-trust, and embracing one's truth.
Sodalite can work to relieve symptoms of menopause, and reduces inflammation in the body for issues such as sinus infection, headaches, and muscle strain.
Sodalite resonates with the throat chakra.


We thank and spotlight our sponsors here. Check out the early-believer business owners, who started supporting ALL4FREEDOM, while others needed proof of concept first. These are our heroes from the very start, who identify with the cause, kindly contribute and lead the way for many more to come. We will soon, and proudly, present you other, and future, sponsors. All of the companies below, and many more, have helped out, ALL4FREEDOM instead of an invoice. By offering their own core-business/talent in product, service or expertise, they supported the cause, completely without funds and money. Ready to join the club?
Currently, there are 10 Heroes in this list.


text:
Q: Parsing non blocked XML with Elemttree I am attempting to parse some XML data and place it into a nested dictionary for later use. However as the XML data is not structured, as I understand it in a child type format or blocked data format I am not sure on the best approach. I am currently trying to use XPath and think this is the best option with this data structure but I am not sure how to parse it in a fashion that will allow me to add it to my nested dictionary correctly. I have tried the below method, but as you may have guessed it's not correct. Could someone advice on the best method to parse this data?
Data To Parse
<address addr="192.168.1.74" addrtype="ipv4"/>
<address addr="FC:75:16:03:D0:2A" addrtype="mac" vendor="D-Link International"/>
<hostnames>
</hostnames>
<ports><extraports state="closed" count="994">
<extrareasons reason="resets" count="994"/>
</extraports>
<port protocol="tcp" portid="80"><state state="open" reason="syn-ack" reason_ttl="64"/><service name="http" product="lighttpd" method="probed" conf="10"><cpe>cpe:/a:lighttpd:lighttpd</cpe></service></port>
<port protocol="tcp" portid="139"><state state="open" reason="syn-ack" reason_ttl="64"/><service name="netbios-ssn" product="Samba smbd" version="3.X" extrainfo="workgroup: WORKGROUP" method="probed" conf="10"/></port>
<port protocol="tcp" portid="443"><state state="open" reason="syn-ack" reason_ttl="64"/><service name="http" product="lighttpd" tunnel="ssl" method="probed" conf="10"><cpe>cpe:/a:lighttpd:lighttpd</cpe></service></port>
<port protocol="tcp" portid="445"><state state="open" reason="syn-ack" reason_ttl="64"/><service name="netbios-ssn" product="Samba smbd" version="3.X" extrainfo="workgroup: WORKGROUP" method="probed" conf="10"/></port>
<port protocol="tcp" portid="515"><state state="open" reason="syn-ack" reason_ttl="64"/><service name="printer" product="LPRng" extrainfo="Not authorized" method="probed" conf="10"/></port>
<port protocol="tcp" portid="3306"><state state="open" reason="syn-ack" reason_ttl="64"/><service name="mysql" product="MySQL" extrainfo="unauthorized" method="probed" conf="10"><cpe>cpe:/a:mysql:mysql</cpe></service></port>
</ports>
<times srtt="16241" rttvar="1850" to="100000"/>
</host>
<host starttime="1443920156" endtime="1443920210"><status state="up" reason="arp-response" reason_ttl="0"/>
<address addr="192.168.1.126" addrtype="ipv4"/>
<address addr="00:0C:29:30:A1:C9" addrtype="mac" vendor="VMware"/>
<hostnames>
</hostnames>
<ports><extraports state="filtered" count="984">
<extrareasons reason="no-responses" count="984"/>
</extraports>
<port protocol="tcp" portid="53"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="domain" product="Microsoft DNS" version="6.1.7601" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="88"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="kerberos-sec" product="Windows 2003 Kerberos" extrainfo="server time: 2015-10-04 00:56:07Z" ostype="Windows" method="probed" conf="10"><cpe>cpe:/a:microsoft:kerberos</cpe><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="135"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="msrpc" product="Microsoft Windows RPC" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="139"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="netbios-ssn" method="probed" conf="10"/></port>
<port protocol="tcp" portid="389"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="ldap" method="probed" conf="10"/></port>
<port protocol="tcp" portid="445"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="netbios-ssn" method="probed" conf="10"/></port>
<port protocol="tcp" portid="464"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="kpasswd5" method="table" conf="3"/></port>
<port protocol="tcp" portid="593"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="ncacn_http" product="Microsoft Windows RPC over HTTP" version="1.0" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="636"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="tcpwrapped" method="probed" conf="8"/></port>
<port protocol="tcp" portid="3268"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="ldap" method="probed" conf="10"/></port>
<port protocol="tcp" portid="3269"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="tcpwrapped" method="probed" conf="8"/></port>
<port protocol="tcp" portid="49154"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="msrpc" product="Microsoft Windows RPC" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="49155"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="msrpc" product="Microsoft Windows RPC" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="49157"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="ncacn_http" product="Microsoft Windows RPC over HTTP" version="1.0" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="49158"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="msrpc" product="Microsoft Windows RPC" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
<port protocol="tcp" portid="49161"><state state="open" reason="syn-ack" reason_ttl="128"/><service name="msrpc" product="Microsoft Windows RPC" ostype="Windows" method="probed" conf="10"><cpe>cpe:/o:microsoft:windows</cpe></service></port>
</ports>
<times srtt="5951" rttvar="5849" to="100000"/>
</host>
<runstats><finished time="1443920210" timestr="Sun Oct  4 01:56:50 2015" elapsed="53.38" summary="Nmap done at Sun Oct  4 01:56:50 2015; 2 IP addresses (2 hosts up) scanned in 53.38 seconds" exit="success"/><hosts up="2" down="0" total="2"/>
</runstats>
</nmaprun>

Current Attempt
from xml.etree import ElementTree
import os

nmap_file = 'Test.xml'

dictionary = {}
dictionary['host'] = {}
dictionary['host']['port'] = {}
dictionary['host']['port']['service'] = {}

with open(nmap_file, 'rt') as f:
    tree = ElementTree.parse(f)

for node in tree.findall('.//address'):
    if (node.attrib.get('addrtype') == 'ipv4'):
        host = node.attrib.get('addr')
        dictionary['host'] = host
        for node in tree.findall('.//port'):
            port = node.attrib.get('portid')
            dictionary['host']['port'] = port

        for node in tree.findall('.//service'):
            product = node.attrib.get('product')
            dictionary['host']['port']['service'] = product

print dictionary

A: Consider a slightly different approach using the lxml module, xpaths, and lists that are sourced into the nested dictionary. See this informative tutorial on creating nested dictionaries.
import lxml.etree as et
import os

nmap_file = 'Test.xml'
with open(nmap_file, 'rt') as f:
    tree = et.parse(f)

dictionary = {}
hosts = tree.xpath('//host')

for i in range(1, len(hosts)+1):
    hostlist = []
    portlist = []
    servicelist = []

    addrnodes = tree.xpath("//host[{}]/address[@addrtype='ipv4']/@addr".format(i))
    hostlist.append(addrnodes[0])

    portnodes = tree.xpath("//host[{}]/ports/port[string-length(service/@product)>0]/@portid".format(i))
    for pt in portnodes:
        portlist.append(pt)

    servicenodes = tree.xpath("//host[{}]/ports/port/service/@product".format(i))
    for srv in servicenodes:
        servicelist.append(srv)

    for h in hostlist:
        dictionary[h] = {}

    for h in hostlist:
        for p, s in zip(portlist, servicelist):
                dictionary[h][p] = s

print(dictionary)

Output (do note: only ports that have listed service products will show in dictionary)
{'192.168.1.74': {'80': 'lighttpd',
                  '445': 'Samba smbd',
                  '139': 'Samba smbd',
                  '443': 'lighttpd',
                  '515': 'LPRng',
                  '3306': 'MySQL'}}
{'192.168.1.126': {'49161': 'Microsoft Windows RPC',
                   '135': 'Microsoft Windows RPC',
                   '53': 'Microsoft DNS',
                   '49157': 'Microsoft Windows RPC over HTTP',
                   '593': 'Microsoft Windows RPC over HTTP',
                   '49155': 'Microsoft Windows RPC',
                   '49158': 'Microsoft Windows RPC',
                   '88': 'Windows 2003 Kerberos',
                   '49154': 'Microsoft Windows RPC'}}

redpajama_set_name: RedPajamaStackExchange


text:
Audrey E Lorber
Seinfeld: Pilot vs S1Ep2
For a show about nothing, a lot can be said about the similarities and differences between the first episode of the first season and that of the second. Seinfeld premiered clunkily as The Seinfeld Chroniclesin July 1989 after NBC inquired Jerry Seinfeld about writing a television program. Jerry discussed this situation with his friend, comedian and writer Larry David, over lunch and the two wrote a pilot (Armstrong). Pilot episodes of beloved shows are always a little weird to re-watch. Most of the time the show just has not found its distinct tone yet. Often there is also character flip-flopping and a few other discrepancies to the rest of the series in a pilot.
In Seinfeld, there are few major series inconstancies in the pilot, "Good News, Bad News" to the series at large and S2Ep1 "The Ex-Girlfriend". The show's only listed writing credits (aside from editors) on IMDB until 1991 is Larry David and Jerry Seinfeld. So the writing of the two first episodes is consistent, but there is a change in direction. Art Wolff directs the pilot and the pilot only. Tom Cherones steps in to direct the second episode of season one, the season two premiere, and 79 other episodes. In the pilot, the classic jazzy bass Seinfeld theme song plays over Jerry's opening stand-up. The theme song and transition jingles are canon in the first episode to the rest of the series, but the style of the opening credits in the pilot are never seen again.
The show's pilot- not to be confused with Season 4 Episode 23 entitled "The Pilot",which is literally about the characters in the show pitching a pilot of their own show about nothing- begins with the way most audience members would have recognize Jerry Seinfeld at the time: on a stage, doing standup. Having already appeared several times on The Tonight Show and even having a few HBO specials, Jerry Seinfeld was a popular comedian. His character's introduction to the show was smart as Jerry was written as a fictionalized version of himself. Onstage, Seinfeld deliberates his opinions on going out and how we all just want to go back home once we are out: peak relatable content.
The second scene begins in a restaurant I am not quite familiar with. Jerry and George are eating at… Pete's Luncheonette? I am used to an establishing shot of the Tom's Restaurant neon sign and then seeing some main characters in a booth like in the first episode of season two and every other episode. Seinfeld is meeting with George for lunch- typical- but at a round table with chairs. A round table with chairs!? Okay so the seating arrangement is unforgivable to me honestly,but what makes it worse is instead of having Elaine as the token female member of the gang,the pilot gives us a monotone waitress named Claire. "NBC president Warren Littlefield said she was cut because as a waitress,she'd only ever be in diner scenes and would never be a real part of the gang" (White). George complains a little about his coffee and the two talk about women and discuss semantics.
The show really starts off to be one about nothing and is honestly a little boring. The third scene is Jerry doing a load at the laundromat,and get this? He and George are still having the same conversation they were having in the diner about what constitutes as a date. Oh wait, they also share their thoughts on laundry etiquette. The next scene is another stand-up scene. It is also about laundry. So what a first-time spectator might infer is that Jerry Seinfeld is an every-man kind of guy. He's just like you! I personally think a lot of the comedy in the show holds up. Few jokes just do not sit the right way,sure,but as young comic and director Bo Burnham once said "Imagine a nation of young people being deprived of the white-hot comedy of Jerry Seinfeld," satirically regarding Jerry Seinfeld's recent comment about not performing at colleges anymore because audiences were too politically correct.So that sucks to hear, but lots of the show does not reflect this comment.
Next scene, is the first in Jerry's apartment. As a Seinfeld fan, this scene was jarring. As most pilots go,the furniture and set-up of the apartment are not completely consistent with the rest of the series. In another scene in Jerry's apartment in the pilot, Jerry, George, and Kessler go over the do's and don'ts of having women over. Who is Kessler and why does he knock on Jerry's door and own a dog? Kessler is played by Michael Richards, the same actor who portrays Kramer in every other episode of Seinfeld. Kramer, however, distinctly does not knock on Jerry's door as the character's signature move is his comedically abrupt entrance into Seinfeld's apartment. The name discrepancy is actually tied up slyly in the last season in a flashback sequence in which the name "Kessler" is the name on Kramer's door buzzer when he first moved in and in perfect Kramer fashion, he did not remove it (Nigro). Also, that dog is just never seen again and is likely just used to integrate a joke.
So from the pilot, the formula is step one: Jerry does a general, relatable stand-up. Next, Jerry introduces something that is going to happen in the episode. He discusses it with his friends in the diner. Then there's a cycle of stand-up relating to the prior scene and a narrative-driven scene and so on. Also, there is just no Julia Louis-Dreyfus at all in the pilot and this is a major concern and critique of mine. According to the mini behind-the-scenes documentary on the Seinfeld: Season 1 DVD, Julia Louis-Dreyfus comments that not only was she unaware of this pilot episode until 2004, but she has never even seen it (Stice). Honestly, I do not blame her.
Seinfeld was a monumental game-changer and rightfully acclaimed sensation. The show was so popular,it has been said that Frank Sinatra made it to the hospital so quickly on the night of his death because everyone was home watching the season finale of Seinfeld (Tolsky). Seinfeld was not always regarded as something that could become a marvel nine season show, let alone even a two season one. "NBC executives were on the fence about the show, fearing that it was just 'too New York and too Jewish.' NBC's head of late night programming, Rick Ludwin was able to convince the network to produce four more episodes.None of them did especially well,but when NBC reran the pilot in 1990 it received a Nielsen rating of 13.9, better than its original score of 10.9. This helped convince the Network to produce another season" (Stice).
The second season opens with Jerry doing stand-up about traffic. Relatable comedy consistency? Check.In the next scene, George laments to Jerry how he wrongfully reciprocated an "I love you" to a woman he wants to break up with. Soon, Elaine joins the two in the car. Yes, you read that correctly. Jerry owns and drives around a car in New York City. Ridiculous, I know, but it is somehow not an inconsistency. There are multiple plots in the series that feature the car, that by the way, is not at all mentioned in the pilot. Once in the vehicle, Elaine brings up neighbor etiquette. A lot of this show is one character bringing up a situation that occurs in everyday life and then opening the floor for the other characters to give their opinions on it, mulling over semantics and pet-peeves. This is also the formula in the pilot, which makes sense because there is no change in the writing staff until season 3. The rest of the episode plays out similarly to the first episode cycle of narrative-driven scenes and respective stand-up comedy performances.
So, Seinfeld had a shaky beginning. Larry David even remembers saying goodbye to Jerry after the pilot was filmed because he did not think he would see him again for a few of years (Mellor). Nobody could have seen the eventual and unprecedented success of the show about nothing from the pilot episode. Under new direction, the swapping of a round table for a booth, and the addition of the legendary Julia Louis-Dreyfus after "Good News, Bad News",Seinfeld began to find its groove and grow an audience. Elaine, Kramer, George, and Seinfeld would go on to become beloved and eccentric caricatures of the everyday New Yorkers that fell in love with the show's reflections on life's semantics.
White, Brett. "'Seinfeld' Aired Its Bizarro Pilot 30 Years Ago Today." Decider, Decider, 5 July 2019, decider.com/2019/07/05/seinfeld-pilot-30-anniversary/.
Armstrong, Jennifer Keishin. Seinfeldia: How a Show about Nothing Changed Everything. Simon & Schuster Paperbacks, an Imprint of Simon & Schuster, Inc., 2017.
Tolsky, Molly. "Nancy Sinatra Missed Her Father's Death Because of 'Seinfeld' Finale." Jewish Telegraphic Agency, 11 Dec. 2019, www.jta.org/jewniverse/2018/nancy-sinatra-missed-her-fathers-death-because-of-seinfeld-finale.
Nigro, Nicholas J. Seinfeld FAQ: Everything Left to Know about the Show about Nothing. Applause Theater & Cinema Books, An Imprint of Hal Leonard Corporation, 2015.
Stice, Joel. "What Was The Deal With The 'Seinfeld' Pilot? Here Are 10 Things You Probably Didn't Know About It." UPROXX, UPROXX, 12 Mar. 2019, uproxx.com/tv/10-fascinating-facts-about-the-seinfeld-pilot/3/.
Mellor, Louisa. "Seinfeld: From Flop to Acclaimed Hit." Den of Geek, 31 May 2016, www.denofgeek.com/us/tv/seinfeld/241125/seinfeld-from-flop-to-acclaimed-hit.
Staircase Movie Genre (A Horror Subgenre)
Coming of Age Bedrooms Onscreen
I want to discuss how teenage bedrooms in coming of age films are a microcosm of the character's story and a reflection of their personality. Movies about teenagers. Coming-of-Age films hold a special
Why the Rise of Streaming Services Should be Embraced
There are a lot of factors that go into where you choose to watch tv: price, accessibility, and of course, content. Today I want to talk about why the seemingly sudden and rapid rise in streaming pla


Aquarium air pumps are an essential part of any aquarium setup. They help stabilize pH as well as provide necessary oxygen for respiration. Aquarium air pumps will also help give your aquarium tank a more dynamic look when used with action aquarium decorations and nice bubbling air stones.


text:
Piața Av. Stan Săraru este prima și în același timp cea mai mare piață agroalimentară modernă a orașului Buzău. A fost concepută în stil cubist, fiind proiectată și construită de cunoscutul arhitect român Duiliu Marcu. Ea este realizarea cea mai importantă a primarului interbelic Stan Săraru în efortul său de a moderniza Buzăul.

Istoric
Proiectul a fost aprobat de Consiliul Tehnic Superior prin jurnalul nr. 172/31 iulie 1934, iar pentru execuție s-a contractat un împrumut de 30.000 lei. În octombrie 1934 s-a introdus instalația electrică, iar la 20 aprilie 1935 s-a alcătuit Regulamentul pentru administrarea, funcționarea și întreținerea pieței orașului Buzău. Contractul de lucrări s-a încheiat la 4 septembrie 1934 cu Societatea Edilitatea din București, conform licitației din 28 august 1934, iar  proiectul a fost întocmit de arhitectul Duiliu Marcu din București, tot el fiind și diriginte de șantier. Costul lucrărilor a fost estimat la 9.409.291 lei.

După Revoluția Română din 1989, prin Decizia Prefecturii Buzău nr.137/03.05.1991, piața primește numele inițiatorului ei, avocatul Stan Săraru. În decursul timpului importanța ei economică crește continuu, este lărgită și renovată de mai multe ori și este acoperită în întregimea ei.

Arhitectură
Piața este pentru perioada interbelică o construcție remarcabilă care portă cu sine amprenta stilului  modernist în arhitectură. Ea pune în evidență un suflu de noutate în arhitectura urbană locală și mai ales o viziune nouă asupra spațiului locuibil având caracteristicele stilului cubist. Construcțiile de acest gen sunt puternic geometrizate, părând că totul se reduce la un univers de scheme geometrice și de cuburi. Este un ansamblu urbanistic la propriu avangardist. Chiar și dispunerea spațiilor comerciale crează un nou ideal de ordine și de igienă. Un astfel de stabiliment comercial poate să pară, pentru lumea tradiționalistă din acea epocă, îndrăzneț dacă nu chiar excentric.

Descriere
La încheierea lucrărilor, pe unul din pilonii porții centrale de acces s-a fixat o placă comemorativă cu următorul text: Construcția acestui ansamblu urbanistic a fost hotărâtă în ședința din 17 august 1934 de către consiliul comunal format din: Stan Săraru, primar; Petre N.Oprescu, Vasile G.Dumitrescu și Nae Iordache, ajutori de primar; Jaures Benea, Elisa Popovici, Justin Stănescu, Alexandru Raiciu, Cristea Teodoru, Nicolae Smeianu, Ștefan Teodorescu, Alexandru Tunaru, Ștefan Matei, Stere Simionescu, Nicolae Miulescu, Nicu Bucur, Teodor Georgescu, căpitanul Dumitru  Staicovici, Gheorghe Anghel, Coman Georgescu, Iancu Movileanu, Iancu Marcovici, Emanoil Homoriceanu, Florica Anastasiu, Valeriu Trandaf, Constantin Ionescu–Smeianu, Nicolae I.Dragomirescu, Constantin Mănăilă, Gheorghe Marinescu – consilieri aleși și Gheorghe V. Stănescu, Nicolae Alexandrescu, preot Grigore Popescu, rabin Simon Bercovici, Necula Stoicescu, Remus Nestor, dr. C. Panaitescu, dr. veterinar D. Teodorescu, Ion Diaconescu, Vasile M.Teodoru, consilieri de drept.

Proiectul inițial includea o hală de carne cu 21 boxe, o alta de pește cu 10 boxe, o hală de alimente și alta de păsări, restaurant, oficiu poștal, chioșc pentru comercializarea laptelui, 47 boxe pentru zarzavat, 13 boxe pentru fructe, inclusiv instalațiile aferente, apele reziduale fiind colectate de fose septice.

În 2019 piața se prezintă astfel: suprafață totala 5230 mp, suprafață platou (60 tarabe pentru citrice, 440 tarabe pentru legume și fructe) acoperită în totalitate 1668,4 mp, pavele din beton. Dotare: tonete cu suprafață din beton mozaicat, cu spațiu de păstrarea mărfurilor, cu posibilitatea de închidere, cu protecție și aerisire, sursă apa potabilă, curent electric, canalizare, acoperire platou din poliplan, hidranți incendiu.

Referințe

Bibliografie

Vezi și
 Stan Săraru#Mandatul de primar

Centre comerciale din Buzău
Fondări în 1934
Piețe din Buzău

redpajama_set_name: RedPajamaWikipedia


text:
Internet/Online Services
Suspect you're arguing with a bot on Twitter? There's a tool for that — several, in fact
By MarketWatch
Published: Mar 31, 2018 9:10 a.m. ET
IUNI/CNetS
Their efficacy is as yet uncertain, let alone their capacity to elevate public discourse and renew faith in democratic norms, but tools are emerging to help social-media users ascertain which posts are likeliest to be coming from bots, or accounts that operate autonomously according to a software developer's directions, and trolls, which with human hands engaged seek chiefly to provoke.
One tool for sussing out whether a social-media account is legit seems to have an edge at this writing. For one thing, it's been developed in part by an institute at a highly reputable university, Indiana University. For another, it's garnered coverage in a notable media trade journal published under the auspices of another esteemed institution, Columbia University. A third factor: It's not only branded but rebranded. The former BotOrNot tool is now known as:
'Botometer'
Catchy branding and, at least in recent days, reliable function separate the Botometer and another entrant to the field on a site called Make Adverbs Great Again, which assigns scores on a 10-point scale where 10/10 is said to connote, almost certainly, a bot, while the Botometer feeds back a percentage of likelihood. Another tool, Botcheck.me, has been lauded by the website The Next Web as handy "not just for ensuring you don't waste your time picking fights with algorithms, but also for seeing who is trying to influence your opinion." Further rivals are doubtless in the works.


text:
Athlete >
Latest Athlete News
George Ezra Is Not A Fan Of Collaborating With Other Artists
George Ezra hates collaborating with other artists. The 'Anyone For You (Tiger Lily)' singer - who is gearing up to release his third studio album, 'Gold Rush Kid', on June 10 - has no desire...
By Bang Showbiz in Music / Festivals on 22 March 2022
George Ezra Ed Sheeran Sam Smith Athlete
Athlete Quick Links News Video Music Press RSS
Athlete Quick Links
News Video Music Press RSS
Bands Index: 0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z


text:
Medical Freedom Alliance (UK), Nature Article on Wuhan – 10 million Tested, German "Enabling Act," 2020, Article 11, No Evidence of a Pandemic.
UK Medical Freedom – New Group/Website
www.ukmedfreedom.org…
I was recently contacted by this group and so am including a link here. The site speaks for itself, of course.
Post-lockdown SARS-CoV-2 nucleic acid screening in nearly ten million residents of Wuhan, China
Is it really infectious?
www.nature.com/artic…
Stringent COVID-19 control measures were imposed in Wuhan between January 23 and April 8, 2020. Estimates of the prevalence of infection following the release of restrictions could inform post-lockdown pandemic management. Here, we describe a city-wide SARS-CoV-2 nucleic acid screening programme between May 14 and June 1, 2020 in Wuhan. All city residents aged six years or older were eligible and 9,899,828 (92.9%) participated. No new symptomatic cases and 300 asymptomatic cases (detection rate 0.303/10,000, 95% CI 0.270–0.339/10,000) were identified. There were no positive tests amongst 1,174 close contacts of asymptomatic cases. 107 of 34,424 previously recovered COVID-19 patients tested positive again (re-positive rate 0.31%, 95% CI 0.423–0.574%). The prevalence of SARS-CoV-2 infection in Wuhan was therefore very low five to eight weeks after the end of lockdown.
Shop owner refuses to close over 'complete injustice' of Covid rules
Yes, big businesses can often open normally, while small ones just get hassled by the council and police. ALL of them should be open and not have to stock certain goods to even make them eligible! It's all based on lies – but not enough people doing these interviews point this out, sadly….
The Germans are back
off-guardian.org/202…
CJ Hopkins
Break out the Wagner, folks…the Germans are back! No, not the warm, fuzzy, pussified, peace-loving, post-war Germans … the Germans! You know the ones I mean. The "I didn't know where the trains were going" Germans. The "I was just following orders" Germans. The other Germans.
Yeah…those Germans.
In case you missed it, on November 18, the German parliament passed a law, the so-called "Infection Protection Act" ("Das Infektionsschutzgesetz" in German) formally granting the government the authority to issue whatever edicts it wants under the guise of protecting the public health.
The government has been doing this anyway — ordering lockdowns, curfews, travel bans, banning demonstrations, raiding homes and businesses, ordering everyone to wear medical masks, harassing and arresting dissidents, etc. — but now it has been "legitimized" by the Bundestag, enshrined into law, and presumably stamped with one of those intricate official stamps that German bureaucrats like to stamp things with.
Now, this "Infection Protection Act," which was rushed through the parliament, is not in any way comparable to the "Enabling Act of 1933," which formally granted the government the authority to issue whatever edicts it wanted under the guise of remedying the distress of the people.
Yes, I realize that sounds quite similar, but, according to the government and the German media, there is absolutely no equivalence whatsoever, and anyone who suggests there is "a far-right AfD extremist," "a neo-Nazi conspiracy theorist," or "an anti-vax esotericist," or whatever.
As the Protection Act was being legitimized (i.e., the current one, not the one in 1933), tens of thousands of anti-totalitarian protesters gathered in the streets, many of them carrying copies of the Grundgesetz (i.e., the constitution of the Federal Republic of Germany), which the parliament had just abrogated. They were met by thousands of riot police, who declared the demonstration "illegal" (because many of the protesters were not wearing masks), beat up and arrested hundreds of them, and then hosed down the rest with water cannons.
The most accurate tests in Italy give 50% false positives
www.oltre.tv/tamponi…
False Negative Tests for SARS-CoV-2 Infection — Challenges and Implications
A few months old, but still very relevant.
There is broad consensus that widespread SARS-CoV-2 testing is essential to safely reopening the United States. A big concern has been test availability, but test accuracy may prove a larger long-term problem.
While debate has focused on the accuracy of antibody tests, which identify prior infection, diagnostic testing, which identifies current infection, has received less attention. But inaccurate diagnostic tests undermine efforts at containment of the pandemic.
Diagnostic tests (typically involving a nasopharyngeal swab) can be inaccurate in two ways. A false positive result erroneously labels a person infected, with consequences including unnecessary quarantine and contact tracing. False negative results are more consequential, because infected persons — who might be asymptomatic — may not be isolated and can infect others.
Given the need to know how well diagnostic tests rule out infection, it's important to review assessment of test accuracy by the Food and Drug Administration (FDA) and clinical researchers, as well as interpretation of test results in a pandemic.
UK – Peaceful Protesting and Human Rights Article 11 – and the Police
This speaker argues that you should just ask a police officer if he is following his oath – which is to protect human rights. One of these is freedom of assembly. The video is a little repetitive in places, but makes many important points of law.
No Evidence of a Pandemic in Liverpool, UK…
"City mayor Joe Anderson said 23,170 people have been tested since midday on Friday 8th Nov with 0.7% testing positive."
BBC – 10th Nov 2020
www.bbc.co.uk/news/u…
FW: Very strong article on geoengineering
Spiricom Study – Dr Stephen Rorke
FW: In Memoriam: Infant Deaths & Vaccination
Pfizer Vaccine, Portugal and PCR Testing, Fox News and the Globalists, Danish Mask Study, US Sheriffs Refuse to Comply
The removal of one of Truth's Protective Layers?