← Back to branch summary

~ubuntu-branches/ubuntu/breezy/atlas-cpp/breezy

« back to all changes in this revision

Viewing changes to Atlas/Codecs/Packed.h

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2005-10-02 11:41:44 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051002114144-8qmn4d1cdn9g27ta
Tags: 0.5.98-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
Atlas/Codecs/Packed.h
5
5
#ifndef ATLAS_CODECS_PACKED_H
6
6
#define ATLAS_CODECS_PACKED_H
7
7
 
8
 
#include <iostream>
9
 
#include <stack>
10
 
 
11
8
#include <Atlas/Codecs/Utility.h>
12
9
#include <Atlas/Codec.h>
13
10
 
 
11
#include <iosfwd>
 
12
#include <stack>
 
13
 
14
14
namespace Atlas { namespace Codecs {
15
15
 
16
16
/*
34
34
    
35
35
*/
36
36
  
37
 
class Packed : public Codec<std::iostream>
 
37
class Packed : public Codec
38
38
{
39
39
public:
40
40
    
41
 
    Packed(std::iostream& s, Atlas::Bridge* b);
 
41
    Packed(std::iostream& s, Atlas::Bridge & b);
42
42
 
43
43
    virtual void poll(bool can_read = true);
44
44
 
45
45
    virtual void streamBegin();
46
 
    virtual void streamMessage(const Map&);
 
46
    virtual void streamMessage();
47
47
    virtual void streamEnd();
48
48
 
49
 
    virtual void mapItem(const std::string& name, const Map&);
50
 
    virtual void mapItem(const std::string& name, const List&);
51
 
    virtual void mapItem(const std::string& name, long);
52
 
    virtual void mapItem(const std::string& name, double);
53
 
    virtual void mapItem(const std::string& name, const std::string&);
 
49
    virtual void mapMapItem(const std::string& name);
 
50
    virtual void mapListItem(const std::string& name);
 
51
    virtual void mapIntItem(const std::string& name, long);
 
52
    virtual void mapFloatItem(const std::string& name, double);
 
53
    virtual void mapStringItem(const std::string& name, const std::string&);
54
54
    virtual void mapEnd();
55
55
    
56
 
    virtual void listItem(const Map&);
57
 
    virtual void listItem(const List&);
58
 
    virtual void listItem(long);
59
 
    virtual void listItem(double);
60
 
    virtual void listItem(const std::string&);
 
56
    virtual void listMapItem();
 
57
    virtual void listListItem();
 
58
    virtual void listIntItem(long);
 
59
    virtual void listFloatItem(double);
 
60
    virtual void listStringItem(const std::string&);
61
61
    virtual void listEnd();
62
62
 
63
63
protected:
64
64
    
65
 
    std::iostream& socket;
66
 
    Bridge* bridge;
 
65
    std::iostream& m_socket;
 
66
    Bridge & m_bridge;
67
67
 
68
68
    enum State
69
69
    {
70
 
        PARSE_STREAM,
 
70
        PARSE_STREAM,
71
71
        PARSE_MAP,
72
72
        PARSE_LIST,
73
 
        PARSE_MAP_BEGIN,
74
 
        PARSE_LIST_BEGIN,
 
73
        PARSE_MAP_BEGIN,
 
74
        PARSE_LIST_BEGIN,
75
75
        PARSE_INT,
76
76
        PARSE_FLOAT,
77
77
        PARSE_STRING,
78
78
        PARSE_NAME
79
79
    };
80
80
    
81
 
    std::stack<State> state;
 
81
    std::stack<State> m_state;
82
82
 
83
 
    std::string name;
84
 
    std::string data;
 
83
    std::string m_name;
 
84
    std::string m_data;
85
85
 
86
86
    inline void parseStream(char);
87
87
    inline void parseMap(char);
95
95
 
96
96
    inline const std::string hexEncode(const std::string& data)
97
97
    {
98
 
        return Atlas::Codecs::hexEncode("+", "+[]()@#$=", data);
 
98
        return hexEncodeWithPrefix("+", "+[]()@#$=", data);
99
99
    }
100
100
 
101
101
    inline const std::string hexDecode(const std::string& data)
102
102
    {
103
 
        return Atlas::Codecs::hexDecode("+", data);
 
103
        return hexDecodeWithPrefix("+", data);
104
104
    }
105
105
};
106
106