public void ReGenerate()
{
m_Queue.Clear();
for (uint i = 1; i <= m_nIDMaxCount; ++i)
{
T obj = m_factory.CreateObject(i);
m_Queue.Enqueue(obj);
}
m_list.Clear();
}
public object InvokeDefaultConstruction(Type type)
{
if (FactoryType == ObjectFactoryType.Class)
{
return(_objectFactory.CreateObject(type));
}
if (FactoryType == ObjectFactoryType.Delegate)
{
return(_default(type));
}
return(null);
}
void ExpandCache(int count)
{
for (int i = 0; i < count; ++i)
{
objects_.Add(objectFactoryMethod_.CreateObject());
}
}
private object CreateCompatibleValue(PaperContext context, object sourceValue, Type targetType)
{
if (sourceValue is PropertyMap map)
{
var instance = objectFactory.CreateObject(targetType);
foreach (var key in map.Keys)
{
var property = targetType.GetProperties().FirstOrDefault(x => x.Name.EqualsIgnoreCase(key));
if (property == null)
{
continue;
}
var value = map[key];
var compatibleValue = CreateCompatibleValue(context, value, property.PropertyType);
property.SetValue(instance, compatibleValue);
}
return(instance);
}
else
{
return(Change.To(sourceValue, targetType));
}
}
private object ReadDocument()
{
// validate data length:
var length = _input.ReadUInt32();
if (length == 0)
{
return(null);
}
// decode data:
var resultObject = new Dictionary <string, object>();
BSonItemType type;
string key;
object value;
int prevOffset;
while ((type = (BSonItemType)_input.ReadByte()) != BSonItemType.EndOfDocument)
{
prevOffset = _input.Offset;
value = ReadItem(type, out key);
if (string.IsNullOrEmpty(key))
{
throw new FormatException("Missing key, when parsing BSON document at " + prevOffset);
}
resultObject[key] = value;
}
return(_factory.CreateObject(resultObject));
}
public virtual T Take()
{
T obj;
if (_pools.Count == 0)
{
obj = _factory.CreateObject(true);
}
else
{
obj = _pools[0];
_factory.ActivateObject(obj);
_pools.RemoveAt(0);
}
_activeCount++;
return(obj);
}
public static object Create(this PaperDescriptor paper, IObjectFactory factory, Type type)
{
var creator = paper.Factories.FirstOrDefault(x => type.IsAssignableFrom(x.ReturnType));
var instance = creator?.Invoke(paper.Paper, null)
?? factory.CreateObject(type);
return(instance);
}
public T Take()
{
T t;
if (pools.Count == 0)
{
t = factory.CreateObject(true);
}
else
{
t = pools[0];
factory.ActivateObject(t);
pools.RemoveAt(0);
}
activeNum++;
return(t);
}
async Task GetPaper(string paper)
{
var descriptor = paperCatalog.FindPaperDescriptor(defaultCatalog, paper);
if (descriptor == null)
{
var ret = Ret.Fail(HttpStatusCode.NotFound, $"O objeto não existe: {defaultCatalog}/{paper}");
await Res.SendEntityStatusAsync(ret);
return;
}
object output;
var instance = objectFactory.CreateObject(descriptor.PaperType);
if (instance._HasMethod("Render"))
{
output = objectFactory.Call(instance, "Render", null);
}
else
{
throw new HttpException($"Não há um algoritmo de renderização conhecido para objeto do tipo ${descriptor.PaperType.FullName}.");
}
if (output is Stream stream)
{
await stream.CopyToAsync(Res.Body);
await Res.Body.FlushAsync();
}
else if (output is StreamReader reader)
{
var encoding = Encoding.UTF8;
var writer = new StreamWriter(Res.Body, encoding);
await reader.CopyToAsync(writer);
await writer.FlushAsync();
await Res.Body.FlushAsync();
}
else if (output is Entity entity)
{
var encoding = Encoding.UTF8;
var mimeType = "json";
var serializer = new MediaSerializer(mimeType);
serializer.Serialize(entity, Res.Body, encoding);
await Res.Body.FlushAsync();
}
else
{
throw new HttpException($"Não há suporte para renderização de dados do tipo {output.GetType().FullName}");
}
}
private void AddExposedCollections <TContract>(IObjectFactory factory, Func <TContract, T> converter)
where TContract : class
{
var types = ExposedTypes.GetTypes <ICatalogCollection <TContract> >();
foreach (var type in types)
{
try
{
var collection = (ICatalogCollection <TContract>)factory.CreateObject(type);
var items = collection.Items.Select(converter);
AddCollection(collection.Name, items);
}
catch (Exception ex)
{
ex.Trace();
}
}
}
private void AddExposedItems <TContract>(IObjectFactory factory, Func <TContract, T> converter)
where TContract : class
{
var types = ExposedTypes.GetTypes <TContract>();
foreach (var type in types)
{
try
{
var contract = (TContract)factory.CreateObject(type);
var collection = contract._GetAttribute <CatalogAttribute>();
var collectionName = collection?.CollectionName ?? type.Assembly.FullName.Split(',').First();
var item = converter.Invoke(contract);
AddCollection(collectionName, item);
}
catch (Exception ex)
{
ex.Trace();
Console.WriteLine(ex.GetStackTrace());
}
}
}
public IPipeline CreatePipeline(IObjectFactory objectFactory)
{
var pipeline = (IPipeline)objectFactory.CreateObject(Type);
return(pipeline);
}
/// <summary>
/// Reads a dictonary from an input stream.
/// </summary>
private object ReadObject()
{
Dictionary <string, object> result = new Dictionary <string, object>();
JSonReaderTokenInfo currentToken;
string name = null;
bool colonSpot = false;
bool commaSpot = false;
int commas = 0;
while ((currentToken = ReadNextToken(true)).Type != JSonReaderTokenType.EndOfText)
{
if (currentToken.Type == JSonReaderTokenType.ObjectEnd)
{
PopTopToken();
// if number of commas is greater than number of added elements,
// then value was not passed between:
if (commas > 0 && commas >= result.Count)
{
throw new JSonReaderException("Too many commas at closing object token, expected none", currentToken);
}
break;
}
switch (currentToken.Type)
{
case JSonReaderTokenType.ArrayStart:
// read embedded array:
AddValue(result, ref name, ReadArray(), ref colonSpot, ref commaSpot, currentToken);
break;
case JSonReaderTokenType.ObjectStart:
// read embedded object:
AddValue(result, ref name, ReadObject(), ref colonSpot, ref commaSpot, currentToken);
break;
case JSonReaderTokenType.Keyword:
if (name == null)
{
throw new JSonReaderException("Keyword can not be an object element's name", currentToken);
}
// add embedded value of reserved keyword:
AddValue(result, ref name, ReadKeyword(), ref colonSpot, ref commaSpot, currentToken);
break;
case JSonReaderTokenType.Number:
// add embedded numeric value:
AddValue(result, ref name, ReadNumber(), ref colonSpot, ref commaSpot, currentToken);
break;
case JSonReaderTokenType.String:
if (!commaSpot && result.Count > 0)
{
throw new JSonReaderException("Missing comma before name and value definition", currentToken);
}
if (name == null)
{
name = ReadString().ToString();
if (result.ContainsKey(name))
{
throw new JSonReaderException("Duplicated name in object", currentToken);
}
break;
}
// add embedded string:
AddValue(result, ref name, ReadString(), ref colonSpot, ref commaSpot, currentToken);
break;
case JSonReaderTokenType.Colon:
PopTopToken();
if (colonSpot)
{
throw new JSonReaderException("Duplicated colon found in object", currentToken);
}
if (name == null)
{
throw new JSonReaderException("Unexpected colon, when name not given", currentToken);
}
colonSpot = true;
break;
case JSonReaderTokenType.Comma:
// go to next array element:
currentToken = PopTopToken();
if (commaSpot)
{
throw new JSonReaderException("Two commans in a row", currentToken);
}
commas++;
commaSpot = true;
// if number of commas is greater than number of added elements,
// then value was not passed between:
if (commas > result.Count)
{
throw new JSonReaderException("Missing value for object element", currentToken);
}
break;
default:
throw new JSonReaderException("Invalid token", currentToken);
}
}
JSonReaderTokenInfo topToken = PopTopToken();
if (topToken.Type != JSonReaderTokenType.ObjectStart || currentToken.Type == JSonReaderTokenType.EndOfText)
{
throw new JSonReaderException("Missing close object token", topToken);
}
return(_factory.CreateObject(result));
}
public static T CreateObject <T>(this IObjectFactory factory, params object[] extraArgs)
{
return((T)factory.CreateObject(typeof(T), extraArgs));
}
public async Task RenderAsync(Request req, Response res, NextAsync next)
{
var path = req.Path.Substring(Route.Length);
// Destacando a ação de uma URI, como em /My/Path/-MyAction
var tokens = path.Split("/-");
var paperPath = tokens.First();
var paperAction = tokens.Skip(1).FirstOrDefault() ?? "Index";
var paper = paperCatalog.FindExact(paperPath).FirstOrDefault();
if (paper == null)
{
await next.Invoke();
return;
}
var hasAction = paper.GetMethod(paperAction) != null;
if (!hasAction)
{
await next.Invoke();
return;
}
var args = new Args();
args.AddMany(req.QueryArgs);
args.AddMany(Args.ParsePathArgs(path, paper.PathTemplate));
var context = new PaperContext();
context.Paper = paper;
context.Path = paperPath;
context.Action = paperAction;
context.Args = args;
context.Request = req;
context.Response = res;
var caller = objectFactory.CreateObject <PaperCaller>();
var renderer = objectFactory.CreateObject <PaperRenderer>();
Ret <Result> result = await caller.CallAsync(context);
if (result.Status.CodeClass != HttpStatusClass.Success)
{
var entity = HttpEntity.CreateFromRet(req.RequestUri, result);
await SendAsync(res, result, entity);
return;
}
Ret <Entity> media = await renderer.RenderAsync(context, result);
if (!media.Ok)
{
var entity = HttpEntity.CreateFromRet(req.RequestUri, result);
await SendAsync(res, media, entity);
return;
}
await SendAsync(res, media, media.Value);
}