fork download

#include <iostream>
#include <vector>
#include <string>
#include <memory>
 
class Visitor;
 
class Entry {
public:
  virtual ~Entry() {};
  virtual std::string getName() const = 0;
  virtual size_t getSize() = 0;
  virtual size_t accept(std::shared_ptr<Visitor>) = 0;
};
 
template <class T>
class Iterator {
public:
  virtual ~Iterator() {}
  virtual bool hasNext() = 0;
  virtual T next() = 0;
};
 
template <class T>
class VectorIterator : public Iterator<T> {
  std::vector<T> &v;
  size_t index = 0;
public:
  VectorIterator(std::vector<T> &v) : v(v) {}
  bool hasNext() override {
    if (index < v.size())
      return true;
    else
      return false;
  }
  T next() {
    T retvalue = v[index];
    index++;
    return retvalue;
  }
};
 
class File : public Entry {
  std::string name;
  size_t size;
public:
  File(std::string name, size_t size) : name(name), size(size) {}
  File(const File &ob) { this->name = ob.name; this->size = ob.size; }
  File(const File *p) { this->name = p->name; this->size = p->size; }
  std::string getName() const override { return name; }
  size_t getSize() override { return size; }
  size_t accept(std::shared_ptr<Visitor>) override;
};
 
class Directory : public Entry {
  std::string name;
  std::vector<std::shared_ptr<Entry>> v;
public:
  Directory(std::string name) : name(name) {}
  Directory(const Directory &ob) { this->name = ob.name; this->v = ob.v; }
  Directory(const Directory *p) { this->name = p->name; this->v = p->v; }
 
//  ~Directory() {
//    for (auto p : v) delete p;
//  }
  std::string getName() const override { return name; }
  size_t getSize() override;
  size_t accept(std::shared_ptr<Visitor> v) override;
  void treePrint();
  void add(std::shared_ptr<Entry> entry) { v.push_back(entry); }
  std::shared_ptr<Iterator<std::shared_ptr<Entry>>> iterator() { return std::make_shared<VectorIterator<std::shared_ptr<Entry>>>(v); }
};
 
class Visitor {
public:
  virtual ~Visitor() {}
  virtual size_t visit(std::shared_ptr<File>) = 0;
  virtual size_t visit(std::shared_ptr<Directory>) = 0;
};
 
size_t File::accept(std::shared_ptr<Visitor> v) { return v->visit(std::make_shared<File>(this)); }
size_t Directory::accept(std::shared_ptr<Visitor> v) { return v->visit(std::make_shared<Directory>(this)); }
 
class SizeVisitor : public Visitor {
 
public:
  SizeVisitor() {};
  SizeVisitor(const SizeVisitor &) {}
  SizeVisitor(const SizeVisitor *) {}
  size_t visit(std::shared_ptr<File> file) { return file->getSize(); }
  size_t visit(std::shared_ptr<Directory> directory) {
    size_t size = 0;
    std::shared_ptr<Iterator<std::shared_ptr<Entry>>> it = directory->iterator();
    while (it->hasNext()) {
      std::shared_ptr<Entry> entry = it->next();
      size += entry->accept(std::make_shared<SizeVisitor>(this));
    }
//    delete it;
    return size;
  }
};
 
class ListVisitor : public Visitor {
  std::string currentDirectoryName;
  std::string saveDirectoryName;
 
public:
  ListVisitor() {}
  ListVisitor(const ListVisitor &ob) {
    this->currentDirectoryName = ob.currentDirectoryName;
    this->saveDirectoryName = ob.saveDirectoryName;
  }
  ListVisitor(const ListVisitor *p) {
    this->currentDirectoryName = p->currentDirectoryName;
    this->saveDirectoryName = p->saveDirectoryName;
  }
  size_t visit(std::shared_ptr<File> file) {
    std::cout << currentDirectoryName << "/" << file->getName() << "(" << file->getSize() << ")" << std::endl;
    return 0;
  }
  size_t visit(std::shared_ptr<Directory> dir) {
    std::cout << currentDirectoryName << "/" << dir->getName() << "(" << dir->getSize() << ")" << std::endl;
    saveDirectoryName = currentDirectoryName;
    currentDirectoryName +=  "/" + dir->getName();
    std::shared_ptr<Iterator<std::shared_ptr<Entry>>> it = dir->iterator();
    while (it->hasNext()) {
      std::shared_ptr<Entry> entry = it->next();
      entry->accept(std::make_shared<ListVisitor>(this));
    }
//    delete it;
    currentDirectoryName = saveDirectoryName;
    return 0;
  }
};
 
size_t Directory::getSize() {
  auto visitor = std::make_shared<SizeVisitor>();
  size_t size = this->accept(visitor);
//  delete visitor;
  return size;
}
void Directory::treePrint() {
  auto visitor = std::make_shared<ListVisitor>();
  this->accept(visitor);
//  delete visitor;
}
 
int main() {
  {
    auto rootdir = std::make_shared<Directory>("root");
    auto file1 = std::make_shared<File>("file1.txt", 100);
    auto file2 = std::make_shared<File>("file2.txt", 200);  
    rootdir->add(file1);
    rootdir->add(file2);
    rootdir->treePrint();
 
    //  delete rootdir;
  }
  xmallocdump();
  return 0;
}
 
 

prog.cpp:36:5: warning: 'next' overrides a member function but is not marked 'override' [-Winconsistent-missing-override]
  T next() {
    ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/type_traits:1354:46: note: in instantiation of template class 'VectorIterator<std::shared_ptr<Entry> >' requested here
               typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
                                                    ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/type_traits:1354:29: note: while substituting deduced template arguments into function template '__test_aux' [with _To1 = Iterator<std::shared_ptr<Entry> > *]
               typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
                                   ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/type_traits:1356:2: note: in instantiation of default argument for '__test<VectorIterator<std::shared_ptr<Entry> > *, Iterator<std::shared_ptr<Entry> > *>' required here
        __test(int);
        ^~~~~~~~~~~
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/type_traits:1363:24: note: while substituting deduced template arguments into function template '__test' [with _From1 = VectorIterator<std::shared_ptr<Entry> > *, _To1 = Iterator<std::shared_ptr<Entry> > *, $2 = (no value)]
      typedef decltype(__test<_From, _To>(0)) type;
                       ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/type_traits:1370:14: note: in instantiation of template class 'std::__is_convertible_helper<VectorIterator<std::shared_ptr<Entry> > *, Iterator<std::shared_ptr<Entry> > *, false>' requested here
    : public __is_convertible_helper<_From, _To>::type
             ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/shared_ptr_base.h:926:7: note: (skipping 4 contexts in backtrace; use -ftemplate-backtrace-limit=0 to see all)
    : is_convertible<_Yp*, _Tp*>::type
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/type_traits:921:56: note: while substituting deduced template arguments into function template '__shared_ptr' [with _Yp = VectorIterator<std::shared_ptr<Entry> >, $1 = (no value)]
      : public __bool_constant<__is_constructible(_Tp, _Args...)>
                                                       ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/shared_ptr.h:107:4: note: in instantiation of template class 'std::is_constructible<std::__shared_ptr<Iterator<std::shared_ptr<Entry> >, __gnu_cxx::_S_atomic>, const std::shared_ptr<VectorIterator<std::shared_ptr<Entry> > > &>' requested here
          is_constructible<__shared_ptr<_Tp>, _Args...>::value
          ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/shared_ptr.h:245:20: note: in instantiation of template type alias '_Constructible' requested here
               typename = _Constructible<const shared_ptr<_Yp>&>>
                          ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/shared_ptr.h:246:2: note: in instantiation of default argument for 'shared_ptr<VectorIterator<std::shared_ptr<Entry> > >' required here
        shared_ptr(const shared_ptr<_Yp>& __r) noexcept
        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
prog.cpp:71:73: note: while substituting deduced template arguments into function template 'shared_ptr' [with _Yp = VectorIterator<std::shared_ptr<Entry> >, $1 = (no value)]
  std::shared_ptr<Iterator<std::shared_ptr<Entry>>> iterator() { return std::make_shared<VectorIterator<std::shared_ptr<Entry>>>(v); }
                                                                        ^
prog.cpp:21:13: note: overridden virtual function is here
  virtual T next() = 0;
            ^
prog.cpp:159:3: error: use of undeclared identifier 'xmallocdump'
  xmallocdump();
  ^
1 warning and 1 error generated.

Standard output is empty