fields.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_FIELDS_HPP
#define KUNAI_DEX_PARSER_FIELDS_HPP
 
#include "Kunai/DEX/parser/types.hpp"
#include "Kunai/DEX/parser/strings.hpp"
#include "Kunai/Utils/kunaistream.hpp"
 
#include <memory>
#include <vector>
 
namespace KUNAI
{
namespace DEX
{
    class EncodedField;
 
    class FieldID
    {
        DVMType* class_;
        DVMType* type_;
        std::string& name_;
        std::string pretty_name;
        EncodedField * encoded_field;
    public:
 
        FieldID(DVMType* class_, DVMType* type_, std::string& name_)
            : class_(class_), type_(type_), name_(name_)
        {
        }
 
        void set_encoded_field(EncodedField * encoded_field)
        {
            this->encoded_field = encoded_field;
        }
 
        EncodedField* get_encoded_field()
        {
            return encoded_field;
        }
 
        ~FieldID() = default;
 
        const DVMType* get_class() const
        {
            return class_;
        }
 
        DVMType* get_class()
        {
            return class_;
        }
 
        const DVMType* get_type() const
        {
            return type_;
        }
 
        DVMType* get_type()
        {
            return type_;
        }
 
        const std::string& get_name() const
        {
            return name_;
        }
 
        std::string& get_name()
        {
            return name_;
        }
 
        std::string& pretty_field();
    };
 
    using fieldid_t = std::unique_ptr<FieldID>;
 
    class Fields
    {
        std::vector<fieldid_t> fields;
 
        std::uint32_t fields_size;
    public:
 
        Fields() = default;
 
        ~Fields() = default;
 
        void parse_fields(
            stream::KunaiStream* stream,
            Types* types,
            Strings* strings,
            std::uint32_t fields_offset,
            std::uint32_t fields_size
        );
 
        const std::vector<fieldid_t>& get_fields() const
        {
            return fields;
        }
 
        std::vector<fieldid_t>& get_fields()
        {
            return fields;
        }
 
        FieldID* get_field(std::uint32_t pos);
 
        std::uint32_t get_number_of_fields() const
        {
            return fields_size;
        }
 
        friend std::ostream& operator<<(std::ostream& os, const Fields& entry);
 
        void to_xml(std::ofstream& fos);
    };
} // namespace DEX
} // namespace KUNAI
 
 
#endif