blob: 1c65782e980e2d897a8bd93b78a7c2f1d7a73252 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/*
* Copyright (c) 2017 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __VOM_SUB_INTERFACE_H__
#define __VOM_SUB_INTERFACE_H__
#include "vom/interface.hpp"
namespace VOM {
/**
* A Sub-interface. e.g. a VLAN sub-interface on an Ethernet interface
*/
class sub_interface : public interface
{
/*
* Typedef for VLAN ID
*/
typedef uint16_t vlan_id_t;
public:
/**
* Construct a new object matching the desried state
*/
sub_interface(const interface& parent, admin_state_t state, vlan_id_t vlan);
/**
* Destructor
*/
~sub_interface();
/**
* Copy Constructor
*/
sub_interface(const sub_interface& o);
/**
* comparison operator - for UT
*/
bool operator==(const sub_interface& s) const;
/**
* Return the matching 'singular instance' of the sub-interface
*/
std::shared_ptr<sub_interface> singular() const;
/**
* Find a subinterface from its key
*/
static std::shared_ptr<sub_interface> find(const key_t& k);
private:
/**
* Construct with handle
*/
sub_interface(const handle_t& handle,
const interface& parent,
admin_state_t state,
vlan_id_t vlan);
friend class interface_factory;
/**
* The interface class can construct interfaces with handles
*/
friend class interface;
/**
* Return the matching 'instance' of the sub-interface
* over-ride from the base class
*/
std::shared_ptr<interface> singular_i() const;
/**
* Virtual functions to construct an interface create commands.
*/
virtual std::queue<cmd*>& mk_create_cmd(std::queue<cmd*>& cmds);
/**
* Virtual functions to construct an interface delete commands.
*/
virtual std::queue<cmd*>& mk_delete_cmd(std::queue<cmd*>& cmds);
/**
* From the name of the parent and the vlan,
* construct the sub-interface's name
*/
static std::string mk_name(const interface& parent, vlan_id_t vlan);
/**
* Refernece conter lock on the parent
*/
const std::shared_ptr<interface> m_parent;
/**
* VLAN ID
*/
vlan_id_t m_vlan;
};
};
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "mozilla")
* End:
*/
#endif
|
