hunt.proton.codec.transport.DetachType source code

1 /*
2  * hunt-proton: AMQP Protocol library for D programming language.
3  *
4  * Copyright (C) 2018-2019 HuntLabs
5  *
6  * Website: https://www.huntlabs.net/
7  *
8  * Licensed under the Apache-2.0 License.
9  *
10  */
11 
12 
13 module hunt.proton.codec.transport.DetachType;
14 
15 import hunt.collection.AbstractList;
16 import hunt.collection.List;
17 import hunt.proton.amqp.Symbol;
18 import hunt.proton.amqp.UnsignedInteger;
19 import hunt.proton.amqp.UnsignedLong;
20 import hunt.proton.amqp.transport.Detach;
21 import hunt.proton.amqp.transport.ErrorCondition;
22 import hunt.proton.codec.AbstractDescribedType;
23 import hunt.proton.codec.DecodeException;
24 import hunt.proton.codec.Decoder;
25 import hunt.proton.codec.DescribedTypeConstructor;
26 import hunt.proton.codec.EncoderImpl;
27 import std.concurrency : initOnce;
28 import hunt.logging;
29 import hunt.Boolean;
30 
31 class DetachWrapper : AbstractList!Object
32 {
33 
34     private Detach _detach;
35 
36     this(Detach detach)
37     {
38         _detach = detach;
39     }
40 
41     override
42     Object get(int index)
43     {
44 
45         switch(index)
46         {
47             case 0:
48             return _detach.getHandle();
49             case 1:
50             return _detach.getClosed();
51             case 2:
52             return _detach.getError();
53             default:
54             return null;
55         }
56 
57         //     throw new IllegalStateException("Unknown index " ~ index);
58 
59     }
60 
61     override
62     int size()
63     {
64         return _detach.getError() !is null
65         ? 3
66         : _detach.getClosed().booleanValue()
67         ? 2
68         : 1;
69 
70     }
71 }
72 
73 class DetachType : AbstractDescribedType!(Detach,List!Object) , DescribedTypeConstructor!(Detach)
74 {
75     //private static Object[] DESCRIPTORS =
76     //{
77     //    UnsignedLong.valueOf(0x0000000000000016L), Symbol.valueOf("amqp:detach:list"),
78     //};
79     //
80     //private static UnsignedLong DESCRIPTOR = UnsignedLong.valueOf(0x0000000000000016L);
81 
82 
83      static Object[]  DESCRIPTORS() {
84          __gshared Object[]  inst;
85          return initOnce!inst([UnsignedLong.valueOf(0x0000000000000016L), Symbol.valueOf("amqp:detach:list")]);
86      }
87 
88          static UnsignedLong  DESCRIPTOR() {
89              __gshared UnsignedLong  inst;
90              return initOnce!inst(UnsignedLong.valueOf(0x0000000000000016L));
91          }
92 
93     this(EncoderImpl encoder)
94     {
95         super(encoder);
96     }
97 
98     override
99     protected UnsignedLong getDescriptor()
100     {
101         return DESCRIPTOR;
102     }
103 
104     override
105     protected List!Object wrap(Detach val)
106     {
107         return new DetachWrapper(val);
108     }
109 
110 
111 
112     Detach newInstance(Object described)
113     {
114         List!Object l = cast(List!Object) described;
115         
116         version(HUNT_AMQP_DEBUG) {
117             size_t index = 0;
118             foreach (Object obj; l) {
119                 if(obj is null) {
120                     tracef("Object[%d] is null", index);
121                 } else {
122                     tracef("Object[%d]: %s ,%s", index, typeid(obj), obj.toString());
123                 }
124                 index++;
125             }
126         }
127 
128         Detach o = new Detach();
129 
130         if(l.isEmpty())
131         {
132             logError("The handle field cannot be omitted");
133             //throw new DecodeException("The handle field cannot be omitted");
134         }
135 
136         switch(3 - l.size())
137         {
138 
139             case 0:
140                 o.setError( cast(ErrorCondition) l.get( 2 ) );
141                 goto case;
142             case 1:
143                 Boolean closed = cast(Boolean) l.get(1);
144                 o.setClosed(closed is null ? Boolean.FALSE : closed);
145                 // o.setClosed(Boolean.TRUE);
146                 goto case;
147             case 2:
148                 o.setHandle( cast(UnsignedInteger) l.get( 0 ) );
149                 break;
150             default:
151                 break;
152         }
153 
154 
155         return o;
156     }
157 
158     TypeInfo getTypeClass()
159     {
160         return typeid(Detach);
161     }
162 
163 
164     static void register(Decoder decoder, EncoderImpl encoder)
165     {
166         DetachType type = new DetachType(encoder);
167         foreach(Object descriptor ; DESCRIPTORS)
168         {
169             decoder.registerDynamic(descriptor, type);
170         }
171         encoder.register(type);
172     }
173 
174 }
175