void HTMLParser :: showTree( const TNodeShared aNode, int aSpacing ) {
TNodeListShared children = aNode->getChildNodes();
int length = children->getLength();
if ( length != 0 ) {
for ( int i = 0; i < length; i++ ) {
TNodeShared child = make_shared( children->item( i ) );
for ( int j = 0; j < aSpacing; j++ ) {
cout << " ";
}
cout << "Child name: " << child->getNodeName().c_str() << endl;
if ( child->getNodeType() == ELEMENT_NODE ) {
// Check for attributes
TNamedNodeMapShared attributes = child->getAttributes();
for ( unsigned int j = 0; j < attributes->getLength(); j++ ) {
TNodeWeak attr = attributes->item( j );
TNodeShared tempAttr = make_shared( attr );
for ( int j = 0; j < aSpacing + 1; j++ ) {
cout << " ";
}
cout << "Attribute " << tempAttr->getNodeName();
cout << " with value " << tempAttr->getNodeValue() << endl;
}
}
showTree( child, aSpacing + 1 );
}
}
}
Expression::Ptr InstructionDecoderImpl::makeAddExpression(Expression::Ptr lhs,
Expression::Ptr rhs, Result_Type resultType)
{
static BinaryFunction::funcT::Ptr adder(new BinaryFunction::addResult());
return make_shared(singleton_object_pool<BinaryFunction>::construct(lhs, rhs, resultType, adder));
}
std::shared_ptr<VersionForRestore> BackupSystem::compute_latest_version(version_number_t version_number){
std::shared_ptr<VersionForRestore> latest_version;
std::map<version_number_t, std::shared_ptr<VersionForRestore>> versions;
std::vector<version_number_t> stack;
const auto &latest_version_number = version_number;
{
auto version = make_shared(new VersionForRestore(latest_version_number, *this, this->keypair.get()));
versions[latest_version_number] = version;
for (auto &object : version->get_base_objects())
this->old_objects.push_back(object);
for (auto &dep : version->get_manifest()->version_dependencies)
versions[dep] = make_shared(new VersionForRestore(dep, *this, this->keypair.get()));
}
latest_version = versions[latest_version_number];
latest_version->fill_dependencies(versions);
return latest_version;
}
Expression::Ptr InstructionDecoderImpl::makeRegisterExpression(MachRegister registerID)
{
int newID = registerID.val();
int minusArch = newID & ~(registerID.getArchitecture());
int convertedID = minusArch | m_Arch;
MachRegister converted(convertedID);
return make_shared(singleton_object_pool<RegisterAST>::construct(converted, 0, registerID.size() * 8));
}
static std::shared_ptr<T> get_instance()
{
static std::shared_ptr<T> instance;
static std::mutex lock;
if (instance) return instance;
std::lock_guard<decltype(lock)> guard(lock);
if (instance) return instance;
instance = make_shared();
return instance;
}
Instruction::Ptr InstructionDecoderImpl::decode(InstructionDecoder::buffer& b)
{
//setMode(m_Arch == Arch_x86_64);
const unsigned char* start = b.start;
decodeOpcode(b);
unsigned int decodedSize = b.start - start;
return make_shared(singleton_object_pool<Instruction>::construct(
m_Operation, decodedSize, start, m_Arch));
}
std::vector<std::shared_ptr<FileSystemObject>> BackupSystem::get_old_objects(ArchiveReader &archive, version_number_t v){
boost::filesystem::ifstream file(this->get_aux_fso_path(v), std::ios::binary);
if (!file)
return archive.get_base_objects();
boost::iostreams::stream<LzmaInputFilter> lzma(file);
std::vector<std::shared_ptr<FileSystemObject>> ret;
buffer_t mem;
while (simple_buffer_deserialization(mem, lzma)){
boost::iostreams::stream<MemorySource> stream(&mem);
ImplementedDeserializerStream ds(stream);
auto fso = make_shared(ds.begin_deserialization<FileSystemObject>(config::include_typehashes));
ret.push_back(fso);
auto mbp = fso->get_unmapped_base_path();
if (!mbp)
continue;
auto mapped = this->map_forward(*mbp).wstring();
fso->set_mapped_base_path(make_shared(new decltype(mapped)(mapped)));
}
return ret;
}
Immediate::Ptr Immediate::makeImmediate(const Result &val) {
//static std::map<Result, Immediate::Ptr> builtImmediates;
//static int cache_hits = 0;
//std::map<Result, Immediate::Ptr>::const_iterator foundIt = builtImmediates.find(val);
//if(foundIt == builtImmediates.end())
//{
Immediate::Ptr ret = make_shared(singleton_object_pool<Immediate>::construct(val));
//builtImmediates[val] = ret;
return ret;
//}
//return foundIt->second;
}
boost::shared_ptr<socket_core> time_socket::start_timer(size_t second)
{
boost::system::error_code ec;
if (!timer_core)
{
make_shared(timer_core, core->get_io());
}
timer_core->expires_from_now(boost::posix_time::seconds(second), ec);
if (ec)
return boost::shared_ptr<socket_core>();
timer_core->async_wait(boost::bind(&time_socket::timer_handler, shared_from_this(), _1));
return core;
}
static std::shared_ptr<T> get_instance ()
{
static std::weak_ptr<T> instance;
static std::mutex lock;
auto x = instance.lock();
if (x) return x;
std::lock_guard<decltype(lock)> guard(lock);
x = instance.lock();
if (x) return x;
x = make_shared();
instance = x;
return x;
}
std::shared_ptr<BackupStream> BackupSystem::generate_initial_stream(FileSystemObject &fso, known_guids_t &known_guids){
if (!this->should_be_added(fso, known_guids)){
this->fix_up_stream_reference(fso, known_guids);
return std::shared_ptr<BackupStream>();
}
auto &filish = static_cast<FilishFso &>(fso);
auto ret = make_shared(new FullStream);
ret->set_unique_id(filish.get_stream_id());
ret->set_physical_size(filish.get_size());
ret->set_virtual_size(filish.get_size());
if (filish.get_file_system_guid().valid)
known_guids[filish.get_file_system_guid().data] = ret;
ret->add_file_system_object(&filish);
return ret;
}
void BackupSystem::perform_restore(
const std::shared_ptr<VersionForRestore> &latest_version,
const restore_vt &restore_later){
std::vector<std::shared_ptr<std::thread>> threads;
threads.reserve(std::thread::hardware_concurrency());
std::mutex mutex;
auto begin = restore_later.begin();
auto end = restore_later.end();
while (threads.size() < threads.capacity())
threads.push_back(make_shared(new std::thread(restore_thread, this, &begin, &end, &mutex)));
while (threads.size()){
threads.back()->join();
threads.pop_back();
}
}
int main()
{
int i;
pthread_t child[NUM_CHILDREN];
Shared *shared = make_shared();
child[0] = make_thread(producer_entry, shared);
child[1] = make_thread(consumer_entry, shared);
for (i=0; i<NUM_CHILDREN; i++) {
join_thread(child[i]);
}
return 0;
}
int main ()
{
int i;
pthread_t child[NUM_CHILDREN];
Shared *shared = make_shared (100000000);
for (i=0; i<NUM_CHILDREN; i++) {
child[i] = make_thread (entry, shared);
}
for (i=0; i<NUM_CHILDREN; i++) {
join_thread (child[i]);
}
check_array (shared);
return 0;
}
void BackupSystem::set_base_objects(){
if (this->base_objects_set)
return;
this->base_objects_set = true;
std::shared_ptr<std::vector<std::wstring>> for_later_check(new std::vector<std::wstring>);
FileSystemObject::CreationSettings settings = {
this,
make_shared(new SimpleErrorReporter),
this->make_map(for_later_check)
};
for (auto ¤t_source_location : this->get_current_source_locations()){
auto mapped = this->map_forward(current_source_location);
std::shared_ptr<FileSystemObject> fso(FileSystemObject::create(mapped, current_source_location, settings));
fso->set_is_main(true);
this->base_objects.push_back(fso);
}
while (for_later_check->size()){
auto old_for_later_check = for_later_check;
for_later_check.reset(new std::vector<std::wstring>);
settings.backup_mode_map = this->make_map(for_later_check);
for (auto &path : *old_for_later_check){
if (this->covered(path))
continue;
std::shared_ptr<FileSystemObject> fso(
FileSystemObject::create(
this->map_forward(path),
path,
settings
)
);
this->base_objects.push_back(fso);
}
}
int i = 0;
for (auto &fso : this->base_objects)
fso->set_entry_number(i++);
this->recalculate_file_guids();
}
StoragePtr StorageSystemEvents::create(const std::string & name_)
{
return make_shared(name_);
}
int test1() {
int child = fork();
int i;
data_t* smem;
pid_t mypid;
int cooloffs = 5;
sched_param_t params = {1, 50, cooloffs};
int status;
int counter = 0;
if (child != 0) {
smem = (data_t*)make_shared(sizeof(data_t), 1);
smem->curr = 0;
mypid = getpid();
ASSERT_POSITIVE(mypid);
nice(1); // be nicer than child
ASSERT_ZERO(sched_setscheduler(mypid, SCHED_SHORT, ¶ms));
ASSERT_EQUALS(sched_setscheduler(mypid, SCHED_SHORT, ¶ms), -1);
ASSERT_EQUALS(errno, EPERM);
ASSERT_EQUALS(is_SHORT(mypid), 1);
smem->arr[smem->curr] = FATHER+0; // init value
ASSERT_ZERO(sched_setscheduler(child, SCHED_SHORT, ¶ms)); // now we lost control until child will be overdue
// child got into overdue. we gained control again. we should still be short here.
smem->arr[++smem->curr] = FATHER+1;
while (is_SHORT(mypid)) ;
smem->arr[++smem->curr] = FATHER+(1*10)+OVERDUE_PERIOD; // got into first overdue period
ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-1);
for (i = 1; i <= cooloffs; ++i) {
while (!is_SHORT(mypid)) ;
smem->arr[++smem->curr] = FATHER+(i*10); // got out of overdue period
ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-i);
while (is_SHORT(mypid)) ;
smem->arr[++smem->curr] = FATHER+((i+1)*10)+OVERDUE_PERIOD; // got into overdue period
ASSERT_EQUALS(remaining_cooloffs(mypid), max(cooloffs-(i+1), 0));
}
// now should be overdue forever
ASSERT_ZERO(remaining_cooloffs(mypid));
waitpid(child, &status, 0);
// use `gcc -DVERBOSE ...` in order to print the array state
if (IS_VERBOSE()) {
for (i = 0; i <= 24; i++) {
printf("%d:\t%d\n", i, smem->arr[i]);
}
}
// check array
ASSERT_EQUALS(smem->arr[0], FATHER+0);
ASSERT_EQUALS(smem->arr[1], SON+0);
ASSERT_EQUALS(smem->arr[2], FATHER+1);
ASSERT_EQUALS(smem->arr[3], SON+10+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[4], SON+10);
ASSERT_EQUALS(smem->arr[5], FATHER+10+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[6], FATHER+10);
ASSERT_EQUALS(smem->arr[7], SON+20+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[8], SON+20);
ASSERT_EQUALS(smem->arr[9], FATHER+20+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[10], FATHER+20);
ASSERT_EQUALS(smem->arr[11], SON+30+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[12], SON+30);
ASSERT_EQUALS(smem->arr[13], FATHER+30+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[14], FATHER+30);
ASSERT_EQUALS(smem->arr[15], SON+40+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[16], SON+40);
ASSERT_EQUALS(smem->arr[17], FATHER+40+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[18], FATHER+40);
ASSERT_EQUALS(smem->arr[19], SON+50+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[20], SON+50);
ASSERT_EQUALS(smem->arr[21], FATHER+50+OVERDUE_PERIOD);
ASSERT_EQUALS(smem->arr[22], FATHER+50);
ASSERT_EQUALS(smem->arr[23], SON+60+OVERDUE_PERIOD); // son finished
ASSERT_EQUALS(smem->arr[24], FATHER+60+OVERDUE_PERIOD);
return 1;
} else {
pid_t mypid = getpid();
ASSERT_POSITIVE(mypid);
while (is_SHORT(mypid) != 1) ;
data_t* smem = (data_t*)make_shared(sizeof(data_t), 0);
smem->arr[++smem->curr] = SON+0; // this is the first SHORT time slice
while (is_SHORT(mypid)) ;
smem->arr[++smem->curr] = SON+(1*10)+OVERDUE_PERIOD; // got into first overdue period
ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-1);
for (i = 1; i <= cooloffs; ++i) {
while (!is_SHORT(mypid)) ;
smem->arr[++smem->curr] = SON+(i*10); // got out of overdue period
ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-i);
while (is_SHORT(mypid)) ;
smem->arr[++smem->curr] = SON+((i+1)*10)+OVERDUE_PERIOD; // got into overdue period
ASSERT_EQUALS(remaining_cooloffs(mypid), max(cooloffs-(i+1), 0));
}
// now should be overdue forever
ASSERT_ZERO(remaining_cooloffs(mypid));
exit(0);
}
return 0;
}
boost::shared_ptr<socket_core> asio_tools::make_socket(boost::asio::io_service & io, protocal::protocal_type type)
{
boost::shared_ptr<socket_core> ptr;
return make_shared(ptr, io, type);
}
boost::shared_ptr<boost::asio::signal_set> asio_tools::make_signal(boost::asio::io_service & io)
{
boost::shared_ptr<boost::asio::signal_set> ptr;
return make_shared(ptr, io);
}
Expression::Ptr InstructionDecoderImpl::makeDereferenceExpression(Expression::Ptr addrToDereference,
Result_Type resultType)
{
return make_shared(singleton_object_pool<Dereference>::construct(addrToDereference, resultType));
}
boost::shared_ptr<boost::asio::ip::tcp::acceptor> asio_tools::make_acceptor(boost::asio::io_service & io)
{
boost::shared_ptr<boost::asio::ip::tcp::acceptor> ptr;
return make_shared(ptr, io);
}
Instruction* InstructionDecoderImpl::makeInstruction(entryID opcode, const char* mnem,
unsigned int decodedSize, const unsigned char* raw)
{
Operation::Ptr tmp(make_shared(singleton_object_pool<Operation>::construct(opcode, mnem, m_Arch)));
return singleton_object_pool<Instruction>::construct(tmp, decodedSize, raw, m_Arch);
}
time_socket::time_socket(boost::asio::io_service & io, boost::asio::ssl::context & context, bool need_extern)
{
make_shared(core, io, context, need_extern);
}
time_socket::time_socket(boost::asio::io_service & io, protocal::protocal_type t, bool need_extern)
{
make_shared(core, io, t, need_extern);
}
boost::shared_ptr<boost::asio::ip::tcp::resolver> asio_tools::make_resolver(boost::asio::io_service & io)
{
boost::shared_ptr<boost::asio::ip::tcp::resolver> ptr;
return make_shared(ptr, io);
}
boost::shared_ptr<boost::asio::deadline_timer> asio_tools::make_timer(boost::asio::io_service & io)
{
boost::shared_ptr<boost::asio::deadline_timer> ptr;
return make_shared(ptr, io);
}
StoragePtr StorageSystemDictionaries::create(const std::string & name)
{
return make_shared(name);
}
int main() {
shared_ptr();
shared_ptr_container();
weak_ptr();
make_shared();
}
StoragePtr StorageSystemMerges::create(const std::string & name)
{
return make_shared(name);
}
int OOBase::Environment::get_block(const env_table_t& tabEnv, ScopedArrayPtr<wchar_t>& ptr)
{
if (tabEnv.empty())
return 0;
// Copy and widen to UNICODE
typedef SharedPtr<wchar_t> temp_wchar_t;
// Sort environment block - UNICODE, no-locale, case-insensitive (from MSDN)
struct env_sort
{
bool operator ()(const OOBase::SharedPtr<wchar_t>& s1, const OOBase::SharedPtr<wchar_t>& s2) const
{
return (_wcsicmp(s1.get(),s2.get()) < 0);
}
};
StackAllocator<1024> allocator;
Table<temp_wchar_t,temp_wchar_t,env_sort,AllocatorInstance> wenv(env_sort(),allocator);
size_t total_size = 0;
for (env_table_t::const_iterator i=tabEnv.begin();i;++i)
{
int err = Win32::utf8_to_wchar_t(i->first.c_str(),ptr);
if (!err)
{
// Include \0 and optionally '=' length
size_t len = wcslen(ptr.get());
total_size += len + 1;
temp_wchar_t key = make_shared(static_cast<wchar_t*>(allocator.allocate(len+1,alignment_of<wchar_t>::value)),allocator);
if (!key)
return ERROR_OUTOFMEMORY;
wcscpy(key.get(),ptr.get());
err = Win32::utf8_to_wchar_t(i->second.c_str(),ptr);
if (!err)
{
temp_wchar_t value;
len = wcslen(ptr.get());
if (len)
{
total_size += len + 1;
value = make_shared(static_cast<wchar_t*>(allocator.allocate(len+1,alignment_of<wchar_t>::value)),allocator);
if (!value)
return ERROR_OUTOFMEMORY;
wcscpy(value.get(),ptr.get());
}
if (!wenv.insert(key,value))
return ERROR_OUTOFMEMORY;
}
}
if (err)
return err;
}
// And now copy into one giant block
if (!ptr.resize(total_size + 2))
return ERROR_OUTOFMEMORY;
wchar_t* pout = ptr.get();
for (Table<temp_wchar_t,temp_wchar_t,env_sort,AllocatorInstance>::iterator i=wenv.begin();i;++i)
{
const wchar_t* p = i->first.get();
while (*p != L'\0')
*pout++ = *p++;
p = i->second.get();
if (p && *p != L'\0')
{
*pout++ = L'=';
while (*p != L'\0')
*pout++ = *p++;
}
*pout++ = L'\0';
}
// Terminate with \0
*pout++ = L'\0';
*pout++ = L'\0';
return 0;
}
