methods.hpp

//--------------------------------------------------------------------*- C++ -*-
// Kunai-static-analyzer: library for doing analysis of dalvik files
// @author Farenain <kunai.static.analysis@gmail.com>
// @author Ernesto Java <javaernesto@gmail.com>
//
// @file fields.hpp
// @brief Manage all the data from the fields from the DEX files.
#ifndef KUNAI_DEX_PARSER_METHODS_HPP
#define KUNAI_DEX_PARSER_METHODS_HPP
 
#include "Kunai/DEX/parser/protos.hpp"
#include "Kunai/DEX/parser/strings.hpp"
#include "Kunai/Utils/kunaistream.hpp"
 
#include <memory>
#include <vector>
 
 
namespace KUNAI
{
    namespace DEX
    {
        class EncodedMethod;
 
        class MethodID 
        {
            DVMType* class_;
            ProtoID* proto_;
            std::string& name_;
            std::string pretty_name;
            EncodedMethod * encoded_method;
        public:
            
            MethodID(DVMType* class_, ProtoID* proto_, std::string& name_)
                : class_(class_), proto_(proto_), name_(name_)
            {
            }
 
            ~MethodID() = default;
 
            EncodedMethod * get_encoded_method()
            {
                return encoded_method;
            }
 
            void set_encoded_method(EncodedMethod * e)
            {
                encoded_method = e;
            }
 
            const DVMType* get_class() const
            {
                return class_;
            }
 
            DVMType* get_class()
            {
                return class_;
            }
 
            const ProtoID* get_proto() const
            {
                return proto_;
            }
 
            ProtoID* get_proto()
            {
                return proto_;
            }
 
            const std::string& get_name() const
            {
                return name_;
            }
 
            std::string& get_name()
            {
                return name_;
            }
 
            std::string& pretty_method();
        };
 
        using methodid_t = std::unique_ptr<MethodID>;
 
        class Methods
        {
            std::vector<methodid_t> methods;
 
            std::uint32_t methods_size;
        public:
 
            Methods() = default;
 
            ~Methods() = default;
 
            void parse_methods(
                stream::KunaiStream* stream,
                Types* types,
                Protos* protos,
                Strings* strings,
                std::uint32_t methods_offset,
                std::uint32_t methods_size
            );
 
            const std::vector<methodid_t>& get_methods() const
            {
                return methods;
            }
 
            std::vector<methodid_t>& get_methods()
            {
                return methods;
            }
 
            MethodID* get_method(std::uint32_t pos);
 
            std::uint32_t get_number_of_methods() const
            {
                return methods_size;
            }
 
            friend std::ostream& operator<<(std::ostream& os, const Methods& entry);
 
            void to_xml(std::ofstream& fos);
        };
 
    } // namespace DEX
} // namespace KUNAI
 
#endif